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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [object.h] - Blame information for rev 53

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

Line No. Rev Author Line
1 27 khays
// object.h -- support for an object file for linking in gold  -*- C++ -*-
2
 
3
// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4
// Written by Ian Lance Taylor <iant@google.com>.
5
 
6
// This file is part of gold.
7
 
8
// This program is free software; you can redistribute it and/or modify
9
// it under the terms of the GNU General Public License as published by
10
// the Free Software Foundation; either version 3 of the License, or
11
// (at your option) any later version.
12
 
13
// This program is distributed in the hope that it will be useful,
14
// but WITHOUT ANY WARRANTY; without even the implied warranty of
15
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
// GNU General Public License for more details.
17
 
18
// You should have received a copy of the GNU General Public License
19
// along with this program; if not, write to the Free Software
20
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21
// MA 02110-1301, USA.
22
 
23
#ifndef GOLD_OBJECT_H
24
#define GOLD_OBJECT_H
25
 
26
#include <string>
27
#include <vector>
28
 
29
#include "elfcpp.h"
30
#include "elfcpp_file.h"
31
#include "fileread.h"
32
#include "target.h"
33
#include "archive.h"
34
 
35
namespace gold
36
{
37
 
38
class General_options;
39
class Task;
40
class Cref;
41
class Layout;
42
class Output_data;
43
class Output_section;
44
class Output_file;
45
class Output_symtab_xindex;
46
class Pluginobj;
47
class Dynobj;
48
class Object_merge_map;
49
class Relocatable_relocs;
50
class Symbols_data;
51
 
52
template<typename Stringpool_char>
53
class Stringpool_template;
54
 
55
// Data to pass from read_symbols() to add_symbols().
56
 
57
struct Read_symbols_data
58
{
59
  Read_symbols_data()
60
    : section_headers(NULL), section_names(NULL), symbols(NULL),
61
      symbol_names(NULL), versym(NULL), verdef(NULL), verneed(NULL)
62
  { }
63
 
64
  ~Read_symbols_data();
65
 
66
  // Section headers.
67
  File_view* section_headers;
68
  // Section names.
69
  File_view* section_names;
70
  // Size of section name data in bytes.
71
  section_size_type section_names_size;
72
  // Symbol data.
73
  File_view* symbols;
74
  // Size of symbol data in bytes.
75
  section_size_type symbols_size;
76
  // Offset of external symbols within symbol data.  This structure
77
  // sometimes contains only external symbols, in which case this will
78
  // be zero.  Sometimes it contains all symbols.
79
  section_offset_type external_symbols_offset;
80
  // Symbol names.
81
  File_view* symbol_names;
82
  // Size of symbol name data in bytes.
83
  section_size_type symbol_names_size;
84
 
85
  // Version information.  This is only used on dynamic objects.
86
  // Version symbol data (from SHT_GNU_versym section).
87
  File_view* versym;
88
  section_size_type versym_size;
89
  // Version definition data (from SHT_GNU_verdef section).
90
  File_view* verdef;
91
  section_size_type verdef_size;
92
  unsigned int verdef_info;
93
  // Needed version data  (from SHT_GNU_verneed section).
94
  File_view* verneed;
95
  section_size_type verneed_size;
96
  unsigned int verneed_info;
97
};
98
 
99
// Information used to print error messages.
100
 
101
struct Symbol_location_info
102
{
103
  std::string source_file;
104
  std::string enclosing_symbol_name;
105
  int line_number;
106
};
107
 
108
// Data about a single relocation section.  This is read in
109
// read_relocs and processed in scan_relocs.
110
 
111
struct Section_relocs
112
{
113
  Section_relocs()
114
    : contents(NULL)
115
  { }
116
 
117
  ~Section_relocs()
118
  { delete this->contents; }
119
 
120
  // Index of reloc section.
121
  unsigned int reloc_shndx;
122
  // Index of section that relocs apply to.
123
  unsigned int data_shndx;
124
  // Contents of reloc section.
125
  File_view* contents;
126
  // Reloc section type.
127
  unsigned int sh_type;
128
  // Number of reloc entries.
129
  size_t reloc_count;
130
  // Output section.
131
  Output_section* output_section;
132
  // Whether this section has special handling for offsets.
133
  bool needs_special_offset_handling;
134
  // Whether the data section is allocated (has the SHF_ALLOC flag set).
135
  bool is_data_section_allocated;
136
};
137
 
138
// Relocations in an object file.  This is read in read_relocs and
139
// processed in scan_relocs.
140
 
141
struct Read_relocs_data
142
{
143
  Read_relocs_data()
144
    : local_symbols(NULL)
145
  { }
146
 
147
  ~Read_relocs_data()
148
  { delete this->local_symbols; }
149
 
150
  typedef std::vector<Section_relocs> Relocs_list;
151
  // The relocations.
152
  Relocs_list relocs;
153
  // The local symbols.
154
  File_view* local_symbols;
155
};
156
 
157
// The Xindex class manages section indexes for objects with more than
158
// 0xff00 sections.
159
 
160
class Xindex
161
{
162
 public:
163
  Xindex(int large_shndx_offset)
164
    : large_shndx_offset_(large_shndx_offset), symtab_xindex_()
165
  { }
166
 
167
  // Initialize the symtab_xindex_ array, given the object and the
168
  // section index of the symbol table to use.
169
  template<int size, bool big_endian>
170
  void
171
  initialize_symtab_xindex(Object*, unsigned int symtab_shndx);
172
 
173
  // Read in the symtab_xindex_ array, given its section index.
174
  // PSHDRS may optionally point to the section headers.
175
  template<int size, bool big_endian>
176
  void
177
  read_symtab_xindex(Object*, unsigned int xindex_shndx,
178
                     const unsigned char* pshdrs);
179
 
180
  // Symbol SYMNDX in OBJECT has a section of SHN_XINDEX; return the
181
  // real section index.
182
  unsigned int
183
  sym_xindex_to_shndx(Object* object, unsigned int symndx);
184
 
185
 private:
186
  // The type of the array giving the real section index for symbols
187
  // whose st_shndx field holds SHN_XINDEX.
188
  typedef std::vector<unsigned int> Symtab_xindex;
189
 
190
  // Adjust a section index if necessary.  This should only be called
191
  // for ordinary section indexes.
192
  unsigned int
193
  adjust_shndx(unsigned int shndx)
194
  {
195
    if (shndx >= elfcpp::SHN_LORESERVE)
196
      shndx += this->large_shndx_offset_;
197
    return shndx;
198
  }
199
 
200
  // Adjust to apply to large section indexes.
201
  int large_shndx_offset_;
202
  // The data from the SHT_SYMTAB_SHNDX section.
203
  Symtab_xindex symtab_xindex_;
204
};
205
 
206
// A GOT offset list.  A symbol may have more than one GOT offset
207
// (e.g., when mixing modules compiled with two different TLS models),
208
// but will usually have at most one.  GOT_TYPE identifies the type of
209
// GOT entry; its values are specific to each target.
210
 
211
class Got_offset_list
212
{
213
 public:
214
  Got_offset_list()
215
    : got_type_(-1U), got_offset_(0), got_next_(NULL)
216
  { }
217
 
218
  Got_offset_list(unsigned int got_type, unsigned int got_offset)
219
    : got_type_(got_type), got_offset_(got_offset), got_next_(NULL)
220
  { }
221
 
222
  ~Got_offset_list()
223
  {
224
    if (this->got_next_ != NULL)
225
      {
226
        delete this->got_next_;
227
        this->got_next_ = NULL;
228
      }
229
  }
230
 
231
  // Initialize the fields to their default values.
232
  void
233
  init()
234
  {
235
    this->got_type_ = -1U;
236
    this->got_offset_ = 0;
237
    this->got_next_ = NULL;
238
  }
239
 
240
  // Set the offset for the GOT entry of type GOT_TYPE.
241
  void
242
  set_offset(unsigned int got_type, unsigned int got_offset)
243
  {
244
    if (this->got_type_ == -1U)
245
      {
246
        this->got_type_ = got_type;
247
        this->got_offset_ = got_offset;
248
      }
249
    else
250
      {
251
        for (Got_offset_list* g = this; g != NULL; g = g->got_next_)
252
          {
253
            if (g->got_type_ == got_type)
254
              {
255
                g->got_offset_ = got_offset;
256
                return;
257
              }
258
          }
259
        Got_offset_list* g = new Got_offset_list(got_type, got_offset);
260
        g->got_next_ = this->got_next_;
261
        this->got_next_ = g;
262
      }
263
  }
264
 
265
  // Return the offset for a GOT entry of type GOT_TYPE.
266
  unsigned int
267
  get_offset(unsigned int got_type) const
268
  {
269
    for (const Got_offset_list* g = this; g != NULL; g = g->got_next_)
270
      {
271
        if (g->got_type_ == got_type)
272
          return g->got_offset_;
273
      }
274
    return -1U;
275
  }
276
 
277
  // Return a pointer to the list, or NULL if the list is empty.
278
  const Got_offset_list*
279
  get_list() const
280
  {
281
    if (this->got_type_ == -1U)
282
      return NULL;
283
    return this;
284
  }
285
 
286
  // Abstract visitor class for iterating over GOT offsets.
287
  class Visitor
288
  {
289
   public:
290
    Visitor()
291
    { }
292
 
293
    virtual
294
    ~Visitor()
295
    { }
296
 
297
    virtual void
298
    visit(unsigned int, unsigned int) = 0;
299
  };
300
 
301
  // Loop over all GOT offset entries, calling a visitor class V for each.
302
  void
303
  for_all_got_offsets(Visitor* v) const
304
  {
305
    if (this->got_type_ == -1U)
306
      return;
307
    for (const Got_offset_list* g = this; g != NULL; g = g->got_next_)
308
      v->visit(g->got_type_, g->got_offset_);
309
  }
310
 
311
 private:
312
  unsigned int got_type_;
313
  unsigned int got_offset_;
314
  Got_offset_list* got_next_;
315
};
316
 
317
// Object is an abstract base class which represents either a 32-bit
318
// or a 64-bit input object.  This can be a regular object file
319
// (ET_REL) or a shared object (ET_DYN).
320
 
321
class Object
322
{
323
 public:
324
  typedef std::vector<Symbol*> Symbols;
325
 
326
  // NAME is the name of the object as we would report it to the user
327
  // (e.g., libfoo.a(bar.o) if this is in an archive.  INPUT_FILE is
328
  // used to read the file.  OFFSET is the offset within the input
329
  // file--0 for a .o or .so file, something else for a .a file.
330
  Object(const std::string& name, Input_file* input_file, bool is_dynamic,
331
         off_t offset = 0)
332
    : name_(name), input_file_(input_file), offset_(offset), shnum_(-1U),
333
      is_dynamic_(is_dynamic), is_needed_(false), uses_split_stack_(false),
334
      has_no_split_stack_(false), no_export_(false),
335
      is_in_system_directory_(false), as_needed_(false), xindex_(NULL)
336
  {
337
    if (input_file != NULL)
338
      {
339
        input_file->file().add_object();
340
        this->is_in_system_directory_ = input_file->is_in_system_directory();
341
        this->as_needed_ = input_file->options().as_needed();
342
      }
343
  }
344
 
345
  virtual ~Object()
346
  {
347
    if (this->input_file_ != NULL)
348
      this->input_file_->file().remove_object();
349
  }
350
 
351
  // Return the name of the object as we would report it to the tuser.
352
  const std::string&
353
  name() const
354
  { return this->name_; }
355
 
356
  // Get the offset into the file.
357
  off_t
358
  offset() const
359
  { return this->offset_; }
360
 
361
  // Return whether this is a dynamic object.
362
  bool
363
  is_dynamic() const
364
  { return this->is_dynamic_; }
365
 
366
  // Return whether this object is needed--true if it is a dynamic
367
  // object which defines some symbol referenced by a regular object.
368
  // We keep the flag here rather than in Dynobj for convenience when
369
  // setting it.
370
  bool
371
  is_needed() const
372
  { return this->is_needed_; }
373
 
374
  // Record that this object is needed.
375
  void
376
  set_is_needed()
377
  { this->is_needed_ = true; }
378
 
379
  // Return whether this object was compiled with -fsplit-stack.
380
  bool
381
  uses_split_stack() const
382
  { return this->uses_split_stack_; }
383
 
384
  // Return whether this object contains any functions compiled with
385
  // the no_split_stack attribute.
386
  bool
387
  has_no_split_stack() const
388
  { return this->has_no_split_stack_; }
389
 
390
  // Returns NULL for Objects that are not dynamic objects.  This method
391
  // is overridden in the Dynobj class.
392
  Dynobj*
393
  dynobj()
394
  { return this->do_dynobj(); }
395
 
396
  // Returns NULL for Objects that are not plugin objects.  This method
397
  // is overridden in the Pluginobj class.
398
  Pluginobj*
399
  pluginobj()
400
  { return this->do_pluginobj(); }
401
 
402
  // Get the file.  We pass on const-ness.
403
  Input_file*
404
  input_file()
405
  {
406
    gold_assert(this->input_file_ != NULL);
407
    return this->input_file_;
408
  }
409
 
410
  const Input_file*
411
  input_file() const
412
  {
413
    gold_assert(this->input_file_ != NULL);
414
    return this->input_file_;
415
  }
416
 
417
  // Lock the underlying file.
418
  void
419
  lock(const Task* t)
420
  {
421
    if (this->input_file_ != NULL)
422
      this->input_file_->file().lock(t);
423
  }
424
 
425
  // Unlock the underlying file.
426
  void
427
  unlock(const Task* t)
428
  {
429
    if (this->input_file_ != NULL)
430
      this->input_file()->file().unlock(t);
431
  }
432
 
433
  // Return whether the underlying file is locked.
434
  bool
435
  is_locked() const
436
  { return this->input_file_ != NULL && this->input_file_->file().is_locked(); }
437
 
438
  // Return the token, so that the task can be queued.
439
  Task_token*
440
  token()
441
  {
442
    if (this->input_file_ == NULL)
443
      return NULL;
444
    return this->input_file()->file().token();
445
  }
446
 
447
  // Release the underlying file.
448
  void
449
  release()
450
  {
451
    if (this->input_file_ != NULL)
452
      this->input_file()->file().release();
453
  }
454
 
455
  // Return whether we should just read symbols from this file.
456
  bool
457
  just_symbols() const
458
  { return this->input_file()->just_symbols(); }
459
 
460
  // Return whether this is an incremental object.
461
  bool
462
  is_incremental() const
463
  { return this->do_is_incremental(); }
464
 
465
  // Return the last modified time of the file.
466
  Timespec
467
  get_mtime()
468
  { return this->do_get_mtime(); }
469
 
470
  // Get the number of sections.
471
  unsigned int
472
  shnum() const
473
  { return this->shnum_; }
474
 
475
  // Return a view of the contents of a section.  Set *PLEN to the
476
  // size.  CACHE is a hint as in File_read::get_view.
477
  const unsigned char*
478
  section_contents(unsigned int shndx, section_size_type* plen, bool cache);
479
 
480
  // Adjust a symbol's section index as needed.  SYMNDX is the index
481
  // of the symbol and SHNDX is the symbol's section from
482
  // get_st_shndx.  This returns the section index.  It sets
483
  // *IS_ORDINARY to indicate whether this is a normal section index,
484
  // rather than a special code between SHN_LORESERVE and
485
  // SHN_HIRESERVE.
486
  unsigned int
487
  adjust_sym_shndx(unsigned int symndx, unsigned int shndx, bool* is_ordinary)
488
  {
489
    if (shndx < elfcpp::SHN_LORESERVE)
490
      *is_ordinary = true;
491
    else if (shndx == elfcpp::SHN_XINDEX)
492
      {
493
        if (this->xindex_ == NULL)
494
          this->xindex_ = this->do_initialize_xindex();
495
        shndx = this->xindex_->sym_xindex_to_shndx(this, symndx);
496
        *is_ordinary = true;
497
      }
498
    else
499
      *is_ordinary = false;
500
    return shndx;
501
  }
502
 
503
  // Return the size of a section given a section index.
504
  uint64_t
505
  section_size(unsigned int shndx)
506
  { return this->do_section_size(shndx); }
507
 
508
  // Return the name of a section given a section index.
509
  std::string
510
  section_name(unsigned int shndx)
511
  { return this->do_section_name(shndx); }
512
 
513
  // Return the section flags given a section index.
514
  uint64_t
515
  section_flags(unsigned int shndx)
516
  { return this->do_section_flags(shndx); }
517
 
518
  // Return the section entsize given a section index.
519
  uint64_t
520
  section_entsize(unsigned int shndx)
521
  { return this->do_section_entsize(shndx); }
522
 
523
  // Return the section address given a section index.
524
  uint64_t
525
  section_address(unsigned int shndx)
526
  { return this->do_section_address(shndx); }
527
 
528
  // Return the section type given a section index.
529
  unsigned int
530
  section_type(unsigned int shndx)
531
  { return this->do_section_type(shndx); }
532
 
533
  // Return the section link field given a section index.
534
  unsigned int
535
  section_link(unsigned int shndx)
536
  { return this->do_section_link(shndx); }
537
 
538
  // Return the section info field given a section index.
539
  unsigned int
540
  section_info(unsigned int shndx)
541
  { return this->do_section_info(shndx); }
542
 
543
  // Return the required section alignment given a section index.
544
  uint64_t
545
  section_addralign(unsigned int shndx)
546
  { return this->do_section_addralign(shndx); }
547
 
548
  // Return the output section given a section index.
549
  Output_section*
550
  output_section(unsigned int shndx) const
551
  { return this->do_output_section(shndx); }
552
 
553
  // Given a section index, return the offset in the Output_section.
554
  // The return value will be -1U if the section is specially mapped,
555
  // such as a merge section.
556
  uint64_t
557
  output_section_offset(unsigned int shndx) const
558
  { return this->do_output_section_offset(shndx); }
559
 
560
  // Read the symbol information.
561
  void
562
  read_symbols(Read_symbols_data* sd)
563
  { return this->do_read_symbols(sd); }
564
 
565
  // Pass sections which should be included in the link to the Layout
566
  // object, and record where the sections go in the output file.
567
  void
568
  layout(Symbol_table* symtab, Layout* layout, Read_symbols_data* sd)
569
  { this->do_layout(symtab, layout, sd); }
570
 
571
  // Add symbol information to the global symbol table.
572
  void
573
  add_symbols(Symbol_table* symtab, Read_symbols_data* sd, Layout *layout)
574
  { this->do_add_symbols(symtab, sd, layout); }
575
 
576
  // Add symbol information to the global symbol table.
577
  Archive::Should_include
578
  should_include_member(Symbol_table* symtab, Layout* layout,
579
                        Read_symbols_data* sd, std::string* why)
580
  { return this->do_should_include_member(symtab, layout, sd, why); }
581
 
582
  // Iterate over global symbols, calling a visitor class V for each.
583
  void
584
  for_all_global_symbols(Read_symbols_data* sd,
585
                         Library_base::Symbol_visitor_base* v)
586
  { return this->do_for_all_global_symbols(sd, v); }
587
 
588
  // Iterate over local symbols, calling a visitor class V for each GOT offset
589
  // associated with a local symbol.
590
  void
591
  for_all_local_got_entries(Got_offset_list::Visitor* v) const
592
  { this->do_for_all_local_got_entries(v); }
593
 
594
  // Functions and types for the elfcpp::Elf_file interface.  This
595
  // permit us to use Object as the File template parameter for
596
  // elfcpp::Elf_file.
597
 
598
  // The View class is returned by view.  It must support a single
599
  // method, data().  This is trivial, because get_view does what we
600
  // need.
601
  class View
602
  {
603
   public:
604
    View(const unsigned char* p)
605
      : p_(p)
606
    { }
607
 
608
    const unsigned char*
609
    data() const
610
    { return this->p_; }
611
 
612
   private:
613
    const unsigned char* p_;
614
  };
615
 
616
  // Return a View.
617
  View
618
  view(off_t file_offset, section_size_type data_size)
619
  { return View(this->get_view(file_offset, data_size, true, true)); }
620
 
621
  // Report an error.
622
  void
623
  error(const char* format, ...) const ATTRIBUTE_PRINTF_2;
624
 
625
  // A location in the file.
626
  struct Location
627
  {
628
    off_t file_offset;
629
    off_t data_size;
630
 
631
    Location(off_t fo, section_size_type ds)
632
      : file_offset(fo), data_size(ds)
633
    { }
634
  };
635
 
636
  // Get a View given a Location.
637
  View view(Location loc)
638
  { return View(this->get_view(loc.file_offset, loc.data_size, true, true)); }
639
 
640
  // Get a view into the underlying file.
641
  const unsigned char*
642
  get_view(off_t start, section_size_type size, bool aligned, bool cache)
643
  {
644
    return this->input_file()->file().get_view(this->offset_, start, size,
645
                                               aligned, cache);
646
  }
647
 
648
  // Get a lasting view into the underlying file.
649
  File_view*
650
  get_lasting_view(off_t start, section_size_type size, bool aligned,
651
                   bool cache)
652
  {
653
    return this->input_file()->file().get_lasting_view(this->offset_, start,
654
                                                       size, aligned, cache);
655
  }
656
 
657
  // Read data from the underlying file.
658
  void
659
  read(off_t start, section_size_type size, void* p)
660
  { this->input_file()->file().read(start + this->offset_, size, p); }
661
 
662
  // Read multiple data from the underlying file.
663
  void
664
  read_multiple(const File_read::Read_multiple& rm)
665
  { this->input_file()->file().read_multiple(this->offset_, rm); }
666
 
667
  // Stop caching views in the underlying file.
668
  void
669
  clear_view_cache_marks()
670
  {
671
    if (this->input_file_ != NULL)
672
      this->input_file_->file().clear_view_cache_marks();
673
  }
674
 
675
  // Get the number of global symbols defined by this object, and the
676
  // number of the symbols whose final definition came from this
677
  // object.
678
  void
679
  get_global_symbol_counts(const Symbol_table* symtab, size_t* defined,
680
                           size_t* used) const
681
  { this->do_get_global_symbol_counts(symtab, defined, used); }
682
 
683
  // Get the symbols defined in this object.
684
  const Symbols*
685
  get_global_symbols() const
686
  { return this->do_get_global_symbols(); }
687
 
688
  // Set flag that this object was found in a system directory.
689
  void
690
  set_is_in_system_directory()
691
  { this->is_in_system_directory_ = true; }
692
 
693
  // Return whether this object was found in a system directory.
694
  bool
695
  is_in_system_directory() const
696
  { return this->is_in_system_directory_; }
697
 
698
  // Set flag that this object was linked with --as-needed.
699
  void
700
  set_as_needed()
701
  { this->as_needed_ = true; }
702
 
703
  // Return whether this object was linked with --as-needed.
704
  bool
705
  as_needed() const
706
  { return this->as_needed_; }
707
 
708
  // Return whether we found this object by searching a directory.
709
  bool
710
  searched_for() const
711
  { return this->input_file()->will_search_for(); }
712
 
713
  bool
714
  no_export() const
715
  { return this->no_export_; }
716
 
717
  void
718
  set_no_export(bool value)
719
  { this->no_export_ = value; }
720
 
721
  // Return TRUE if the section is a compressed debug section, and set
722
  // *UNCOMPRESSED_SIZE to the size of the uncompressed data.
723
  bool
724
  section_is_compressed(unsigned int shndx,
725
                        section_size_type* uncompressed_size) const
726
  { return this->do_section_is_compressed(shndx, uncompressed_size); }
727
 
728
  // Return the index of the first incremental relocation for symbol SYMNDX.
729
  unsigned int
730
  get_incremental_reloc_base(unsigned int symndx) const
731
  { return this->do_get_incremental_reloc_base(symndx); }
732
 
733
  // Return the number of incremental relocations for symbol SYMNDX.
734
  unsigned int
735
  get_incremental_reloc_count(unsigned int symndx) const
736
  { return this->do_get_incremental_reloc_count(symndx); }
737
 
738
 protected:
739
  // Returns NULL for Objects that are not dynamic objects.  This method
740
  // is overridden in the Dynobj class.
741
  virtual Dynobj*
742
  do_dynobj()
743
  { return NULL; }
744
 
745
  // Returns NULL for Objects that are not plugin objects.  This method
746
  // is overridden in the Pluginobj class.
747
  virtual Pluginobj*
748
  do_pluginobj()
749
  { return NULL; }
750
 
751
  // Return TRUE if this is an incremental (unchanged) input file.
752
  // We return FALSE by default; the incremental object classes
753
  // override this method.
754
  virtual bool
755
  do_is_incremental() const
756
  { return false; }
757
 
758
  // Return the last modified time of the file.  This method may be
759
  // overridden for subclasses that don't use an actual file (e.g.,
760
  // Incremental objects).
761
  virtual Timespec
762
  do_get_mtime()
763
  { return this->input_file()->file().get_mtime(); }
764
 
765
  // Read the symbols--implemented by child class.
766
  virtual void
767
  do_read_symbols(Read_symbols_data*) = 0;
768
 
769
  // Lay out sections--implemented by child class.
770
  virtual void
771
  do_layout(Symbol_table*, Layout*, Read_symbols_data*) = 0;
772
 
773
  // Add symbol information to the global symbol table--implemented by
774
  // child class.
775
  virtual void
776
  do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*) = 0;
777
 
778
  virtual Archive::Should_include
779
  do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
780
                           std::string* why) = 0;
781
 
782
  // Iterate over global symbols, calling a visitor class V for each.
783
  virtual void
784
  do_for_all_global_symbols(Read_symbols_data* sd,
785
                            Library_base::Symbol_visitor_base* v) = 0;
786
 
787
  // Iterate over local symbols, calling a visitor class V for each GOT offset
788
  // associated with a local symbol.
789
  virtual void
790
  do_for_all_local_got_entries(Got_offset_list::Visitor* v) const = 0;
791
 
792
  // Return the location of the contents of a section.  Implemented by
793
  // child class.
794
  virtual Location
795
  do_section_contents(unsigned int shndx) = 0;
796
 
797
  // Get the size of a section--implemented by child class.
798
  virtual uint64_t
799
  do_section_size(unsigned int shndx) = 0;
800
 
801
  // Get the name of a section--implemented by child class.
802
  virtual std::string
803
  do_section_name(unsigned int shndx) = 0;
804
 
805
  // Get section flags--implemented by child class.
806
  virtual uint64_t
807
  do_section_flags(unsigned int shndx) = 0;
808
 
809
  // Get section entsize--implemented by child class.
810
  virtual uint64_t
811
  do_section_entsize(unsigned int shndx) = 0;
812
 
813
  // Get section address--implemented by child class.
814
  virtual uint64_t
815
  do_section_address(unsigned int shndx) = 0;
816
 
817
  // Get section type--implemented by child class.
818
  virtual unsigned int
819
  do_section_type(unsigned int shndx) = 0;
820
 
821
  // Get section link field--implemented by child class.
822
  virtual unsigned int
823
  do_section_link(unsigned int shndx) = 0;
824
 
825
  // Get section info field--implemented by child class.
826
  virtual unsigned int
827
  do_section_info(unsigned int shndx) = 0;
828
 
829
  // Get section alignment--implemented by child class.
830
  virtual uint64_t
831
  do_section_addralign(unsigned int shndx) = 0;
832
 
833
  // Return the output section given a section index--implemented
834
  // by child class.
835
  virtual Output_section*
836
  do_output_section(unsigned int) const
837
  { gold_unreachable(); }
838
 
839
  // Get the offset of a section--implemented by child class.
840
  virtual uint64_t
841
  do_output_section_offset(unsigned int) const
842
  { gold_unreachable(); }
843
 
844
  // Return the Xindex structure to use.
845
  virtual Xindex*
846
  do_initialize_xindex() = 0;
847
 
848
  // Implement get_global_symbol_counts--implemented by child class.
849
  virtual void
850
  do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const = 0;
851
 
852
  virtual const Symbols*
853
  do_get_global_symbols() const = 0;
854
 
855
  // Set the number of sections.
856
  void
857
  set_shnum(int shnum)
858
  { this->shnum_ = shnum; }
859
 
860
  // Functions used by both Sized_relobj_file and Sized_dynobj.
861
 
862
  // Read the section data into a Read_symbols_data object.
863
  template<int size, bool big_endian>
864
  void
865
  read_section_data(elfcpp::Elf_file<size, big_endian, Object>*,
866
                    Read_symbols_data*);
867
 
868
  // Let the child class initialize the xindex object directly.
869
  void
870
  set_xindex(Xindex* xindex)
871
  {
872
    gold_assert(this->xindex_ == NULL);
873
    this->xindex_ = xindex;
874
  }
875
 
876
  // If NAME is the name of a special .gnu.warning section, arrange
877
  // for the warning to be issued.  SHNDX is the section index.
878
  // Return whether it is a warning section.
879
  bool
880
  handle_gnu_warning_section(const char* name, unsigned int shndx,
881
                             Symbol_table*);
882
 
883
  // If NAME is the name of the special section which indicates that
884
  // this object was compiled with -fsplit-stack, mark it accordingly,
885
  // and return true.  Otherwise return false.
886
  bool
887
  handle_split_stack_section(const char* name);
888
 
889
  // Return TRUE if the section is a compressed debug section, and set
890
  // *UNCOMPRESSED_SIZE to the size of the uncompressed data.
891
  virtual bool
892
  do_section_is_compressed(unsigned int, section_size_type*) const
893
  { return false; }
894
 
895
  // Return the index of the first incremental relocation for symbol SYMNDX--
896
  // implemented by child class.
897
  virtual unsigned int
898
  do_get_incremental_reloc_base(unsigned int) const
899
  { gold_unreachable(); }
900
 
901
  // Return the number of incremental relocations for symbol SYMNDX--
902
  // implemented by child class.
903
  virtual unsigned int
904
  do_get_incremental_reloc_count(unsigned int) const
905
  { gold_unreachable(); }
906
 
907
 private:
908
  // This class may not be copied.
909
  Object(const Object&);
910
  Object& operator=(const Object&);
911
 
912
  // Name of object as printed to user.
913
  std::string name_;
914
  // For reading the file.
915
  Input_file* input_file_;
916
  // Offset within the file--0 for an object file, non-0 for an
917
  // archive.
918
  off_t offset_;
919
  // Number of input sections.
920
  unsigned int shnum_;
921
  // Whether this is a dynamic object.
922
  bool is_dynamic_ : 1;
923
  // Whether this object is needed.  This is only set for dynamic
924
  // objects, and means that the object defined a symbol which was
925
  // used by a reference from a regular object.
926
  bool is_needed_ : 1;
927
  // Whether this object was compiled with -fsplit-stack.
928
  bool uses_split_stack_ : 1;
929
  // Whether this object contains any functions compiled with the
930
  // no_split_stack attribute.
931
  bool has_no_split_stack_ : 1;
932
  // True if exclude this object from automatic symbol export.
933
  // This is used only for archive objects.
934
  bool no_export_ : 1;
935
  // True if the object was found in a system directory.
936
  bool is_in_system_directory_ : 1;
937
  // True if the object was linked with --as-needed.
938
  bool as_needed_ : 1;
939
  // Many sections for objects with more than SHN_LORESERVE sections.
940
  Xindex* xindex_;
941
};
942
 
943
// A regular object (ET_REL).  This is an abstract base class itself.
944
// The implementation is the template class Sized_relobj_file.
945
 
946
class Relobj : public Object
947
{
948
 public:
949
  Relobj(const std::string& name, Input_file* input_file, off_t offset = 0)
950
    : Object(name, input_file, false, offset),
951
      output_sections_(),
952
      map_to_relocatable_relocs_(NULL),
953
      object_merge_map_(NULL),
954
      relocs_must_follow_section_writes_(false),
955
      sd_(NULL),
956
      reloc_counts_(NULL),
957
      reloc_bases_(NULL),
958
      first_dyn_reloc_(0),
959
      dyn_reloc_count_(0)
960
  { }
961
 
962
  // During garbage collection, the Read_symbols_data pass for 
963
  // each object is stored as layout needs to be done after 
964
  // reloc processing.
965
  Symbols_data*
966
  get_symbols_data()
967
  { return this->sd_; }
968
 
969
  // Decides which section names have to be included in the worklist
970
  // as roots.
971
  bool
972
  is_section_name_included(const char* name);
973
 
974
  void
975
  copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
976
                    unsigned int section_header_size);
977
 
978
  void
979
  set_symbols_data(Symbols_data* sd)
980
  { this->sd_ = sd; }
981
 
982
  // During garbage collection, the Read_relocs pass for all objects 
983
  // is done before scanning the relocs.  In that case, this->rd_ is
984
  // used to store the information from Read_relocs for each object.
985
  // This data is also used to compute the list of relevant sections.
986
  Read_relocs_data*
987
  get_relocs_data()
988
  { return this->rd_; }
989
 
990
  void
991
  set_relocs_data(Read_relocs_data* rd)
992
  { this->rd_ = rd; }
993
 
994
  virtual bool
995
  is_output_section_offset_invalid(unsigned int shndx) const = 0;
996
 
997
  // Read the relocs.
998
  void
999
  read_relocs(Read_relocs_data* rd)
1000
  { return this->do_read_relocs(rd); }
1001
 
1002
  // Process the relocs, during garbage collection only.
1003
  void
1004
  gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd)
1005
  { return this->do_gc_process_relocs(symtab, layout, rd); }
1006
 
1007
  // Scan the relocs and adjust the symbol table.
1008
  void
1009
  scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd)
1010
  { return this->do_scan_relocs(symtab, layout, rd); }
1011
 
1012
  // The number of local symbols in the input symbol table.
1013
  virtual unsigned int
1014
  local_symbol_count() const
1015
  { return this->do_local_symbol_count(); }
1016
 
1017
  // The number of local symbols in the output symbol table.
1018
  virtual unsigned int
1019
  output_local_symbol_count() const
1020
  { return this->do_output_local_symbol_count(); }
1021
 
1022
  // The file offset for local symbols in the output symbol table.
1023
  virtual off_t
1024
  local_symbol_offset() const
1025
  { return this->do_local_symbol_offset(); }
1026
 
1027
  // Initial local symbol processing: count the number of local symbols
1028
  // in the output symbol table and dynamic symbol table; add local symbol
1029
  // names to *POOL and *DYNPOOL.
1030
  void
1031
  count_local_symbols(Stringpool_template<char>* pool,
1032
                      Stringpool_template<char>* dynpool)
1033
  { return this->do_count_local_symbols(pool, dynpool); }
1034
 
1035
  // Set the values of the local symbols, set the output symbol table
1036
  // indexes for the local variables, and set the offset where local
1037
  // symbol information will be stored. Returns the new local symbol index.
1038
  unsigned int
1039
  finalize_local_symbols(unsigned int index, off_t off, Symbol_table* symtab)
1040
  { return this->do_finalize_local_symbols(index, off, symtab); }
1041
 
1042
  // Set the output dynamic symbol table indexes for the local variables.
1043
  unsigned int
1044
  set_local_dynsym_indexes(unsigned int index)
1045
  { return this->do_set_local_dynsym_indexes(index); }
1046
 
1047
  // Set the offset where local dynamic symbol information will be stored.
1048
  unsigned int
1049
  set_local_dynsym_offset(off_t off)
1050
  { return this->do_set_local_dynsym_offset(off); }
1051
 
1052
  // Record a dynamic relocation against an input section from this object.
1053
  void
1054
  add_dyn_reloc(unsigned int index)
1055
  {
1056
    if (this->dyn_reloc_count_ == 0)
1057
      this->first_dyn_reloc_ = index;
1058
    ++this->dyn_reloc_count_;
1059
  }
1060
 
1061
  // Return the index of the first dynamic relocation.
1062
  unsigned int
1063
  first_dyn_reloc() const
1064
  { return this->first_dyn_reloc_; }
1065
 
1066
  // Return the count of dynamic relocations.
1067
  unsigned int
1068
  dyn_reloc_count() const
1069
  { return this->dyn_reloc_count_; }
1070
 
1071
  // Relocate the input sections and write out the local symbols.
1072
  void
1073
  relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of)
1074
  { return this->do_relocate(symtab, layout, of); }
1075
 
1076
  // Return whether an input section is being included in the link.
1077
  bool
1078
  is_section_included(unsigned int shndx) const
1079
  {
1080
    gold_assert(shndx < this->output_sections_.size());
1081
    return this->output_sections_[shndx] != NULL;
1082
  }
1083
 
1084
  // The the output section of the input section with index SHNDX.
1085
  // This is only used currently to remove a section from the link in
1086
  // relaxation.
1087
  void
1088
  set_output_section(unsigned int shndx, Output_section* os)
1089
  {
1090
    gold_assert(shndx < this->output_sections_.size());
1091
    this->output_sections_[shndx] = os;
1092
  }
1093
 
1094
  // Set the offset of an input section within its output section.
1095
  void
1096
  set_section_offset(unsigned int shndx, uint64_t off)
1097
  { this->do_set_section_offset(shndx, off); }
1098
 
1099
  // Return true if we need to wait for output sections to be written
1100
  // before we can apply relocations.  This is true if the object has
1101
  // any relocations for sections which require special handling, such
1102
  // as the exception frame section.
1103
  bool
1104
  relocs_must_follow_section_writes() const
1105
  { return this->relocs_must_follow_section_writes_; }
1106
 
1107
  // Return the object merge map.
1108
  Object_merge_map*
1109
  merge_map() const
1110
  { return this->object_merge_map_; }
1111
 
1112
  // Set the object merge map.
1113
  void
1114
  set_merge_map(Object_merge_map* object_merge_map)
1115
  {
1116
    gold_assert(this->object_merge_map_ == NULL);
1117
    this->object_merge_map_ = object_merge_map;
1118
  }
1119
 
1120
  // Record the relocatable reloc info for an input reloc section.
1121
  void
1122
  set_relocatable_relocs(unsigned int reloc_shndx, Relocatable_relocs* rr)
1123
  {
1124
    gold_assert(reloc_shndx < this->shnum());
1125
    (*this->map_to_relocatable_relocs_)[reloc_shndx] = rr;
1126
  }
1127
 
1128
  // Get the relocatable reloc info for an input reloc section.
1129
  Relocatable_relocs*
1130
  relocatable_relocs(unsigned int reloc_shndx)
1131
  {
1132
    gold_assert(reloc_shndx < this->shnum());
1133
    return (*this->map_to_relocatable_relocs_)[reloc_shndx];
1134
  }
1135
 
1136
  // Layout sections whose layout was deferred while waiting for
1137
  // input files from a plugin.
1138
  void
1139
  layout_deferred_sections(Layout* layout)
1140
  { this->do_layout_deferred_sections(layout); }
1141
 
1142
  // Return the index of the first incremental relocation for symbol SYMNDX.
1143
  virtual unsigned int
1144
  do_get_incremental_reloc_base(unsigned int symndx) const
1145
  { return this->reloc_bases_[symndx]; }
1146
 
1147
  // Return the number of incremental relocations for symbol SYMNDX.
1148
  virtual unsigned int
1149
  do_get_incremental_reloc_count(unsigned int symndx) const
1150
  { return this->reloc_counts_[symndx]; }
1151
 
1152
 protected:
1153
  // The output section to be used for each input section, indexed by
1154
  // the input section number.  The output section is NULL if the
1155
  // input section is to be discarded.
1156
  typedef std::vector<Output_section*> Output_sections;
1157
 
1158
  // Read the relocs--implemented by child class.
1159
  virtual void
1160
  do_read_relocs(Read_relocs_data*) = 0;
1161
 
1162
  // Process the relocs--implemented by child class.
1163
  virtual void
1164
  do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*) = 0;
1165
 
1166
  // Scan the relocs--implemented by child class.
1167
  virtual void
1168
  do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*) = 0;
1169
 
1170
  // Return the number of local symbols--implemented by child class.
1171
  virtual unsigned int
1172
  do_local_symbol_count() const = 0;
1173
 
1174
  // Return the number of output local symbols--implemented by child class.
1175
  virtual unsigned int
1176
  do_output_local_symbol_count() const = 0;
1177
 
1178
  // Return the file offset for local symbols--implemented by child class.
1179
  virtual off_t
1180
  do_local_symbol_offset() const = 0;
1181
 
1182
  // Count local symbols--implemented by child class.
1183
  virtual void
1184
  do_count_local_symbols(Stringpool_template<char>*,
1185
                         Stringpool_template<char>*) = 0;
1186
 
1187
  // Finalize the local symbols.  Set the output symbol table indexes
1188
  // for the local variables, and set the offset where local symbol
1189
  // information will be stored.
1190
  virtual unsigned int
1191
  do_finalize_local_symbols(unsigned int, off_t, Symbol_table*) = 0;
1192
 
1193
  // Set the output dynamic symbol table indexes for the local variables.
1194
  virtual unsigned int
1195
  do_set_local_dynsym_indexes(unsigned int) = 0;
1196
 
1197
  // Set the offset where local dynamic symbol information will be stored.
1198
  virtual unsigned int
1199
  do_set_local_dynsym_offset(off_t) = 0;
1200
 
1201
  // Relocate the input sections and write out the local
1202
  // symbols--implemented by child class.
1203
  virtual void
1204
  do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of) = 0;
1205
 
1206
  // Set the offset of a section--implemented by child class.
1207
  virtual void
1208
  do_set_section_offset(unsigned int shndx, uint64_t off) = 0;
1209
 
1210
  // Layout sections whose layout was deferred while waiting for
1211
  // input files from a plugin--implemented by child class.
1212
  virtual void
1213
  do_layout_deferred_sections(Layout*) = 0;
1214
 
1215
  // Given a section index, return the corresponding Output_section.
1216
  // The return value will be NULL if the section is not included in
1217
  // the link.
1218
  Output_section*
1219
  do_output_section(unsigned int shndx) const
1220
  {
1221
    gold_assert(shndx < this->output_sections_.size());
1222
    return this->output_sections_[shndx];
1223
  }
1224
 
1225
  // Return the vector mapping input sections to output sections.
1226
  Output_sections&
1227
  output_sections()
1228
  { return this->output_sections_; }
1229
 
1230
  const Output_sections&
1231
  output_sections() const
1232
  { return this->output_sections_; }
1233
 
1234
  // Set the size of the relocatable relocs array.
1235
  void
1236
  size_relocatable_relocs()
1237
  {
1238
    this->map_to_relocatable_relocs_ =
1239
      new std::vector<Relocatable_relocs*>(this->shnum());
1240
  }
1241
 
1242
  // Record that we must wait for the output sections to be written
1243
  // before applying relocations.
1244
  void
1245
  set_relocs_must_follow_section_writes()
1246
  { this->relocs_must_follow_section_writes_ = true; }
1247
 
1248
  // Allocate the array for counting incremental relocations.
1249
  void
1250
  allocate_incremental_reloc_counts()
1251
  {
1252
    unsigned int nsyms = this->do_get_global_symbols()->size();
1253
    this->reloc_counts_ = new unsigned int[nsyms];
1254
    gold_assert(this->reloc_counts_ != NULL);
1255
    memset(this->reloc_counts_, 0, nsyms * sizeof(unsigned int));
1256
  }
1257
 
1258
  // Record a relocation in this object referencing global symbol SYMNDX.
1259
  // Used for tracking incremental link information.
1260
  void
1261
  count_incremental_reloc(unsigned int symndx)
1262
  {
1263
    unsigned int nsyms = this->do_get_global_symbols()->size();
1264
    gold_assert(symndx < nsyms);
1265
    gold_assert(this->reloc_counts_ != NULL);
1266
    ++this->reloc_counts_[symndx];
1267
  }
1268
 
1269
  // Finalize the incremental relocation information.
1270
  void
1271
  finalize_incremental_relocs(Layout* layout, bool clear_counts);
1272
 
1273
  // Return the index of the next relocation to be written for global symbol
1274
  // SYMNDX.  Only valid after finalize_incremental_relocs() has been called.
1275
  unsigned int
1276
  next_incremental_reloc_index(unsigned int symndx)
1277
  {
1278
    unsigned int nsyms = this->do_get_global_symbols()->size();
1279
 
1280
    gold_assert(this->reloc_counts_ != NULL);
1281
    gold_assert(this->reloc_bases_ != NULL);
1282
    gold_assert(symndx < nsyms);
1283
 
1284
    unsigned int counter = this->reloc_counts_[symndx]++;
1285
    return this->reloc_bases_[symndx] + counter;
1286
  }
1287
 
1288
 private:
1289
  // Mapping from input sections to output section.
1290
  Output_sections output_sections_;
1291
  // Mapping from input section index to the information recorded for
1292
  // the relocations.  This is only used for a relocatable link.
1293
  std::vector<Relocatable_relocs*>* map_to_relocatable_relocs_;
1294
  // Mappings for merge sections.  This is managed by the code in the
1295
  // Merge_map class.
1296
  Object_merge_map* object_merge_map_;
1297
  // Whether we need to wait for output sections to be written before
1298
  // we can apply relocations.
1299
  bool relocs_must_follow_section_writes_;
1300
  // Used to store the relocs data computed by the Read_relocs pass. 
1301
  // Used during garbage collection of unused sections.
1302
  Read_relocs_data* rd_;
1303
  // Used to store the symbols data computed by the Read_symbols pass.
1304
  // Again used during garbage collection when laying out referenced
1305
  // sections.
1306
  gold::Symbols_data* sd_;
1307
  // Per-symbol counts of relocations, for incremental links.
1308
  unsigned int* reloc_counts_;
1309
  // Per-symbol base indexes of relocations, for incremental links.
1310
  unsigned int* reloc_bases_;
1311
  // Index of the first dynamic relocation for this object.
1312
  unsigned int first_dyn_reloc_;
1313
  // Count of dynamic relocations for this object.
1314
  unsigned int dyn_reloc_count_;
1315
};
1316
 
1317
// This class is used to handle relocations against a section symbol
1318
// in an SHF_MERGE section.  For such a symbol, we need to know the
1319
// addend of the relocation before we can determine the final value.
1320
// The addend gives us the location in the input section, and we can
1321
// determine how it is mapped to the output section.  For a
1322
// non-section symbol, we apply the addend to the final value of the
1323
// symbol; that is done in finalize_local_symbols, and does not use
1324
// this class.
1325
 
1326
template<int size>
1327
class Merged_symbol_value
1328
{
1329
 public:
1330
  typedef typename elfcpp::Elf_types<size>::Elf_Addr Value;
1331
 
1332
  // We use a hash table to map offsets in the input section to output
1333
  // addresses.
1334
  typedef Unordered_map<section_offset_type, Value> Output_addresses;
1335
 
1336
  Merged_symbol_value(Value input_value, Value output_start_address)
1337
    : input_value_(input_value), output_start_address_(output_start_address),
1338
      output_addresses_()
1339
  { }
1340
 
1341
  // Initialize the hash table.
1342
  void
1343
  initialize_input_to_output_map(const Relobj*, unsigned int input_shndx);
1344
 
1345
  // Release the hash table to save space.
1346
  void
1347
  free_input_to_output_map()
1348
  { this->output_addresses_.clear(); }
1349
 
1350
  // Get the output value corresponding to an addend.  The object and
1351
  // input section index are passed in because the caller will have
1352
  // them; otherwise we could store them here.
1353
  Value
1354
  value(const Relobj* object, unsigned int input_shndx, Value addend) const
1355
  {
1356
    // This is a relocation against a section symbol.  ADDEND is the
1357
    // offset in the section.  The result should be the start of some
1358
    // merge area.  If the object file wants something else, it should
1359
    // use a regular symbol rather than a section symbol.
1360
    // Unfortunately, PR 6658 shows a case in which the object file
1361
    // refers to the section symbol, but uses a negative ADDEND to
1362
    // compensate for a PC relative reloc.  We can't handle the
1363
    // general case.  However, we can handle the special case of a
1364
    // negative addend, by assuming that it refers to the start of the
1365
    // section.  Of course, that means that we have to guess when
1366
    // ADDEND is negative.  It is normal to see a 32-bit value here
1367
    // even when the template parameter size is 64, as 64-bit object
1368
    // file formats have 32-bit relocations.  We know this is a merge
1369
    // section, so we know it has to fit into memory.  So we assume
1370
    // that we won't see a value larger than a large 32-bit unsigned
1371
    // value.  This will break objects with very very large merge
1372
    // sections; they probably break in other ways anyhow.
1373
    Value input_offset = this->input_value_;
1374
    if (addend < 0xffffff00)
1375
      {
1376
        input_offset += addend;
1377
        addend = 0;
1378
      }
1379
    typename Output_addresses::const_iterator p =
1380
      this->output_addresses_.find(input_offset);
1381
    if (p != this->output_addresses_.end())
1382
      return p->second + addend;
1383
 
1384
    return (this->value_from_output_section(object, input_shndx, input_offset)
1385
            + addend);
1386
  }
1387
 
1388
 private:
1389
  // Get the output value for an input offset if we couldn't find it
1390
  // in the hash table.
1391
  Value
1392
  value_from_output_section(const Relobj*, unsigned int input_shndx,
1393
                            Value input_offset) const;
1394
 
1395
  // The value of the section symbol in the input file.  This is
1396
  // normally zero, but could in principle be something else.
1397
  Value input_value_;
1398
  // The start address of this merged section in the output file.
1399
  Value output_start_address_;
1400
  // A hash table which maps offsets in the input section to output
1401
  // addresses.  This only maps specific offsets, not all offsets.
1402
  Output_addresses output_addresses_;
1403
};
1404
 
1405
// This POD class is holds the value of a symbol.  This is used for
1406
// local symbols, and for all symbols during relocation processing.
1407
// For special sections, such as SHF_MERGE sections, this calls a
1408
// function to get the final symbol value.
1409
 
1410
template<int size>
1411
class Symbol_value
1412
{
1413
 public:
1414
  typedef typename elfcpp::Elf_types<size>::Elf_Addr Value;
1415
 
1416
  Symbol_value()
1417
    : output_symtab_index_(0), output_dynsym_index_(-1U), input_shndx_(0),
1418
      is_ordinary_shndx_(false), is_section_symbol_(false),
1419
      is_tls_symbol_(false), is_ifunc_symbol_(false), has_output_value_(true)
1420
  { this->u_.value = 0; }
1421
 
1422
  ~Symbol_value()
1423
  {
1424
    if (!this->has_output_value_)
1425
      delete this->u_.merged_symbol_value;
1426
  }
1427
 
1428
  // Get the value of this symbol.  OBJECT is the object in which this
1429
  // symbol is defined, and ADDEND is an addend to add to the value.
1430
  template<bool big_endian>
1431
  Value
1432
  value(const Sized_relobj_file<size, big_endian>* object, Value addend) const
1433
  {
1434
    if (this->has_output_value_)
1435
      return this->u_.value + addend;
1436
    else
1437
      {
1438
        gold_assert(this->is_ordinary_shndx_);
1439
        return this->u_.merged_symbol_value->value(object, this->input_shndx_,
1440
                                                   addend);
1441
      }
1442
  }
1443
 
1444
  // Set the value of this symbol in the output symbol table.
1445
  void
1446
  set_output_value(Value value)
1447
  { this->u_.value = value; }
1448
 
1449
  // For a section symbol in a merged section, we need more
1450
  // information.
1451
  void
1452
  set_merged_symbol_value(Merged_symbol_value<size>* msv)
1453
  {
1454
    gold_assert(this->is_section_symbol_);
1455
    this->has_output_value_ = false;
1456
    this->u_.merged_symbol_value = msv;
1457
  }
1458
 
1459
  // Initialize the input to output map for a section symbol in a
1460
  // merged section.  We also initialize the value of a non-section
1461
  // symbol in a merged section.
1462
  void
1463
  initialize_input_to_output_map(const Relobj* object)
1464
  {
1465
    if (!this->has_output_value_)
1466
      {
1467
        gold_assert(this->is_section_symbol_ && this->is_ordinary_shndx_);
1468
        Merged_symbol_value<size>* msv = this->u_.merged_symbol_value;
1469
        msv->initialize_input_to_output_map(object, this->input_shndx_);
1470
      }
1471
  }
1472
 
1473
  // Free the input to output map for a section symbol in a merged
1474
  // section.
1475
  void
1476
  free_input_to_output_map()
1477
  {
1478
    if (!this->has_output_value_)
1479
      this->u_.merged_symbol_value->free_input_to_output_map();
1480
  }
1481
 
1482
  // Set the value of the symbol from the input file.  This is only
1483
  // called by count_local_symbols, to communicate the value to
1484
  // finalize_local_symbols.
1485
  void
1486
  set_input_value(Value value)
1487
  { this->u_.value = value; }
1488
 
1489
  // Return the input value.  This is only called by
1490
  // finalize_local_symbols and (in special cases) relocate_section.
1491
  Value
1492
  input_value() const
1493
  { return this->u_.value; }
1494
 
1495
  // Return whether we have set the index in the output symbol table
1496
  // yet.
1497
  bool
1498
  is_output_symtab_index_set() const
1499
  {
1500
    return (this->output_symtab_index_ != 0
1501
            && this->output_symtab_index_ != -2U);
1502
  }
1503
 
1504
  // Return whether this symbol may be discarded from the normal
1505
  // symbol table.
1506
  bool
1507
  may_be_discarded_from_output_symtab() const
1508
  {
1509
    gold_assert(!this->is_output_symtab_index_set());
1510
    return this->output_symtab_index_ != -2U;
1511
  }
1512
 
1513
  // Return whether this symbol has an entry in the output symbol
1514
  // table.
1515
  bool
1516
  has_output_symtab_entry() const
1517
  {
1518
    gold_assert(this->is_output_symtab_index_set());
1519
    return this->output_symtab_index_ != -1U;
1520
  }
1521
 
1522
  // Return the index in the output symbol table.
1523
  unsigned int
1524
  output_symtab_index() const
1525
  {
1526
    gold_assert(this->is_output_symtab_index_set()
1527
                && this->output_symtab_index_ != -1U);
1528
    return this->output_symtab_index_;
1529
  }
1530
 
1531
  // Set the index in the output symbol table.
1532
  void
1533
  set_output_symtab_index(unsigned int i)
1534
  {
1535
    gold_assert(!this->is_output_symtab_index_set());
1536
    gold_assert(i != 0 && i != -1U && i != -2U);
1537
    this->output_symtab_index_ = i;
1538
  }
1539
 
1540
  // Record that this symbol should not go into the output symbol
1541
  // table.
1542
  void
1543
  set_no_output_symtab_entry()
1544
  {
1545
    gold_assert(this->output_symtab_index_ == 0);
1546
    this->output_symtab_index_ = -1U;
1547
  }
1548
 
1549
  // Record that this symbol must go into the output symbol table,
1550
  // because it there is a relocation that uses it.
1551
  void
1552
  set_must_have_output_symtab_entry()
1553
  {
1554
    gold_assert(!this->is_output_symtab_index_set());
1555
    this->output_symtab_index_ = -2U;
1556
  }
1557
 
1558
  // Set the index in the output dynamic symbol table.
1559
  void
1560
  set_needs_output_dynsym_entry()
1561
  {
1562
    gold_assert(!this->is_section_symbol());
1563
    this->output_dynsym_index_ = 0;
1564
  }
1565
 
1566
  // Return whether this symbol should go into the dynamic symbol
1567
  // table.
1568
  bool
1569
  needs_output_dynsym_entry() const
1570
  {
1571
    return this->output_dynsym_index_ != -1U;
1572
  }
1573
 
1574
  // Return whether this symbol has an entry in the dynamic symbol
1575
  // table.
1576
  bool
1577
  has_output_dynsym_entry() const
1578
  {
1579
    gold_assert(this->output_dynsym_index_ != 0);
1580
    return this->output_dynsym_index_ != -1U;
1581
  }
1582
 
1583
  // Record that this symbol should go into the dynamic symbol table.
1584
  void
1585
  set_output_dynsym_index(unsigned int i)
1586
  {
1587
    gold_assert(this->output_dynsym_index_ == 0);
1588
    gold_assert(i != 0 && i != -1U);
1589
    this->output_dynsym_index_ = i;
1590
  }
1591
 
1592
  // Return the index in the output dynamic symbol table.
1593
  unsigned int
1594
  output_dynsym_index() const
1595
  {
1596
    gold_assert(this->output_dynsym_index_ != 0
1597
                && this->output_dynsym_index_ != -1U);
1598
    return this->output_dynsym_index_;
1599
  }
1600
 
1601
  // Set the index of the input section in the input file.
1602
  void
1603
  set_input_shndx(unsigned int i, bool is_ordinary)
1604
  {
1605
    this->input_shndx_ = i;
1606
    // input_shndx_ field is a bitfield, so make sure that the value
1607
    // fits.
1608
    gold_assert(this->input_shndx_ == i);
1609
    this->is_ordinary_shndx_ = is_ordinary;
1610
  }
1611
 
1612
  // Return the index of the input section in the input file.
1613
  unsigned int
1614
  input_shndx(bool* is_ordinary) const
1615
  {
1616
    *is_ordinary = this->is_ordinary_shndx_;
1617
    return this->input_shndx_;
1618
  }
1619
 
1620
  // Whether this is a section symbol.
1621
  bool
1622
  is_section_symbol() const
1623
  { return this->is_section_symbol_; }
1624
 
1625
  // Record that this is a section symbol.
1626
  void
1627
  set_is_section_symbol()
1628
  {
1629
    gold_assert(!this->needs_output_dynsym_entry());
1630
    this->is_section_symbol_ = true;
1631
  }
1632
 
1633
  // Record that this is a TLS symbol.
1634
  void
1635
  set_is_tls_symbol()
1636
  { this->is_tls_symbol_ = true; }
1637
 
1638
  // Return true if this is a TLS symbol.
1639
  bool
1640
  is_tls_symbol() const
1641
  { return this->is_tls_symbol_; }
1642
 
1643
  // Record that this is an IFUNC symbol.
1644
  void
1645
  set_is_ifunc_symbol()
1646
  { this->is_ifunc_symbol_ = true; }
1647
 
1648
  // Return true if this is an IFUNC symbol.
1649
  bool
1650
  is_ifunc_symbol() const
1651
  { return this->is_ifunc_symbol_; }
1652
 
1653
  // Return true if this has output value.
1654
  bool
1655
  has_output_value() const
1656
  { return this->has_output_value_; }
1657
 
1658
 private:
1659
  // The index of this local symbol in the output symbol table.  This
1660
  // will be 0 if no value has been assigned yet, and the symbol may
1661
  // be omitted.  This will be -1U if the symbol should not go into
1662
  // the symbol table.  This will be -2U if the symbol must go into
1663
  // the symbol table, but no index has been assigned yet.
1664
  unsigned int output_symtab_index_;
1665
  // The index of this local symbol in the dynamic symbol table.  This
1666
  // will be -1U if the symbol should not go into the symbol table.
1667
  unsigned int output_dynsym_index_;
1668
  // The section index in the input file in which this symbol is
1669
  // defined.
1670
  unsigned int input_shndx_ : 27;
1671
  // Whether the section index is an ordinary index, not a special
1672
  // value.
1673
  bool is_ordinary_shndx_ : 1;
1674
  // Whether this is a STT_SECTION symbol.
1675
  bool is_section_symbol_ : 1;
1676
  // Whether this is a STT_TLS symbol.
1677
  bool is_tls_symbol_ : 1;
1678
  // Whether this is a STT_GNU_IFUNC symbol.
1679
  bool is_ifunc_symbol_ : 1;
1680
  // Whether this symbol has a value for the output file.  This is
1681
  // normally set to true during Layout::finalize, by
1682
  // finalize_local_symbols.  It will be false for a section symbol in
1683
  // a merge section, as for such symbols we can not determine the
1684
  // value to use in a relocation until we see the addend.
1685
  bool has_output_value_ : 1;
1686
  union
1687
  {
1688
    // This is used if has_output_value_ is true.  Between
1689
    // count_local_symbols and finalize_local_symbols, this is the
1690
    // value in the input file.  After finalize_local_symbols, it is
1691
    // the value in the output file.
1692
    Value value;
1693
    // This is used if has_output_value_ is false.  It points to the
1694
    // information we need to get the value for a merge section.
1695
    Merged_symbol_value<size>* merged_symbol_value;
1696
  } u_;
1697
};
1698
 
1699
// This type is used to modify relocations for -fsplit-stack.  It is
1700
// indexed by relocation index, and means that the relocation at that
1701
// index should use the symbol from the vector, rather than the one
1702
// indicated by the relocation.
1703
 
1704
class Reloc_symbol_changes
1705
{
1706
 public:
1707
  Reloc_symbol_changes(size_t count)
1708
    : vec_(count, NULL)
1709
  { }
1710
 
1711
  void
1712
  set(size_t i, Symbol* sym)
1713
  { this->vec_[i] = sym; }
1714
 
1715
  const Symbol*
1716
  operator[](size_t i) const
1717
  { return this->vec_[i]; }
1718
 
1719
 private:
1720
  std::vector<Symbol*> vec_;
1721
};
1722
 
1723
// Type for mapping section index to uncompressed size.
1724
 
1725
typedef std::map<unsigned int, section_size_type> Compressed_section_map;
1726
 
1727
// Abstract base class for a regular object file, either a real object file
1728
// or an incremental (unchanged) object.  This is size and endian specific.
1729
 
1730
template<int size, bool big_endian>
1731
class Sized_relobj : public Relobj
1732
{
1733
 public:
1734
  typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
1735
  typedef Relobj::Symbols Symbols;
1736
 
1737
  static const Address invalid_address = static_cast<Address>(0) - 1;
1738
 
1739
  Sized_relobj(const std::string& name, Input_file* input_file)
1740
    : Relobj(name, input_file), local_got_offsets_(), section_offsets_()
1741
  { }
1742
 
1743
  Sized_relobj(const std::string& name, Input_file* input_file,
1744
                    off_t offset)
1745
    : Relobj(name, input_file, offset), local_got_offsets_(), section_offsets_()
1746
  { }
1747
 
1748
  ~Sized_relobj()
1749
  { }
1750
 
1751
  // If this is a regular object, return a pointer to the Sized_relobj_file
1752
  // object.  Otherwise, return NULL.
1753
  virtual Sized_relobj_file<size, big_endian>*
1754
  sized_relobj()
1755
  { return NULL; }
1756
 
1757
  const virtual Sized_relobj_file<size, big_endian>*
1758
  sized_relobj() const
1759
  { return NULL; }
1760
 
1761
  // Checks if the offset of input section SHNDX within its output
1762
  // section is invalid.
1763
  bool
1764
  is_output_section_offset_invalid(unsigned int shndx) const
1765
  { return this->get_output_section_offset(shndx) == invalid_address; }
1766
 
1767
  // Get the offset of input section SHNDX within its output section.
1768
  // This is -1 if the input section requires a special mapping, such
1769
  // as a merge section.  The output section can be found in the
1770
  // output_sections_ field of the parent class Relobj.
1771
  Address
1772
  get_output_section_offset(unsigned int shndx) const
1773
  {
1774
    gold_assert(shndx < this->section_offsets_.size());
1775
    return this->section_offsets_[shndx];
1776
  }
1777
 
1778
  // Return whether the local symbol SYMNDX has a GOT offset.
1779
  // For TLS symbols, the GOT entry will hold its tp-relative offset.
1780
  bool
1781
  local_has_got_offset(unsigned int symndx, unsigned int got_type) const
1782
  {
1783
    Local_got_offsets::const_iterator p =
1784
        this->local_got_offsets_.find(symndx);
1785
    return (p != this->local_got_offsets_.end()
1786
            && p->second->get_offset(got_type) != -1U);
1787
  }
1788
 
1789
  // Return the GOT offset of the local symbol SYMNDX.
1790
  unsigned int
1791
  local_got_offset(unsigned int symndx, unsigned int got_type) const
1792
  {
1793
    Local_got_offsets::const_iterator p =
1794
        this->local_got_offsets_.find(symndx);
1795
    gold_assert(p != this->local_got_offsets_.end());
1796
    unsigned int off = p->second->get_offset(got_type);
1797
    gold_assert(off != -1U);
1798
    return off;
1799
  }
1800
 
1801
  // Set the GOT offset of the local symbol SYMNDX to GOT_OFFSET.
1802
  void
1803
  set_local_got_offset(unsigned int symndx, unsigned int got_type,
1804
                       unsigned int got_offset)
1805
  {
1806
    Local_got_offsets::const_iterator p =
1807
        this->local_got_offsets_.find(symndx);
1808
    if (p != this->local_got_offsets_.end())
1809
      p->second->set_offset(got_type, got_offset);
1810
    else
1811
      {
1812
        Got_offset_list* g = new Got_offset_list(got_type, got_offset);
1813
        std::pair<Local_got_offsets::iterator, bool> ins =
1814
            this->local_got_offsets_.insert(std::make_pair(symndx, g));
1815
        gold_assert(ins.second);
1816
      }
1817
  }
1818
 
1819
  // Iterate over local symbols, calling a visitor class V for each GOT offset
1820
  // associated with a local symbol.
1821
  void
1822
  do_for_all_local_got_entries(Got_offset_list::Visitor* v) const;
1823
 
1824
 protected:
1825
  typedef Relobj::Output_sections Output_sections;
1826
 
1827
  // Clear the local symbol information.
1828
  void
1829
  clear_got_offsets()
1830
  { this->local_got_offsets_.clear(); }
1831
 
1832
  // Return the vector of section offsets.
1833
  std::vector<Address>&
1834
  section_offsets()
1835
  { return this->section_offsets_; }
1836
 
1837
  // Get the offset of a section.
1838
  uint64_t
1839
  do_output_section_offset(unsigned int shndx) const
1840
  {
1841
    Address off = this->get_output_section_offset(shndx);
1842
    if (off == invalid_address)
1843
      return -1ULL;
1844
    return off;
1845
  }
1846
 
1847
  // Set the offset of a section.
1848
  void
1849
  do_set_section_offset(unsigned int shndx, uint64_t off)
1850
  {
1851
    gold_assert(shndx < this->section_offsets_.size());
1852
    this->section_offsets_[shndx] =
1853
      (off == static_cast<uint64_t>(-1)
1854
       ? invalid_address
1855
       : convert_types<Address, uint64_t>(off));
1856
  }
1857
 
1858
 private:
1859
  // The GOT offsets of local symbols. This map also stores GOT offsets
1860
  // for tp-relative offsets for TLS symbols.
1861
  typedef Unordered_map<unsigned int, Got_offset_list*> Local_got_offsets;
1862
 
1863
  // GOT offsets for local non-TLS symbols, and tp-relative offsets
1864
  // for TLS symbols, indexed by symbol number.
1865
  Local_got_offsets local_got_offsets_;
1866
  // For each input section, the offset of the input section in its
1867
  // output section.  This is INVALID_ADDRESS if the input section requires a
1868
  // special mapping.
1869
  std::vector<Address> section_offsets_;
1870
};
1871
 
1872
// A regular object file.  This is size and endian specific.
1873
 
1874
template<int size, bool big_endian>
1875
class Sized_relobj_file : public Sized_relobj<size, big_endian>
1876
{
1877
 public:
1878
  typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
1879
  typedef typename Sized_relobj<size, big_endian>::Symbols Symbols;
1880
  typedef std::vector<Symbol_value<size> > Local_values;
1881
 
1882
  static const Address invalid_address = static_cast<Address>(0) - 1;
1883
 
1884
  enum Compute_final_local_value_status
1885
  {
1886
    // No error.
1887
    CFLV_OK,
1888
    // An error occurred.
1889
    CFLV_ERROR,
1890
    // The local symbol has no output section.
1891
    CFLV_DISCARDED
1892
  };
1893
 
1894
  Sized_relobj_file(const std::string& name,
1895
                    Input_file* input_file,
1896
                    off_t offset,
1897
                    const typename elfcpp::Ehdr<size, big_endian>&);
1898
 
1899
  ~Sized_relobj_file();
1900
 
1901
  // Set up the object file based on TARGET.
1902
  void
1903
  setup()
1904
  { this->do_setup(); }
1905
 
1906
  // Return a pointer to the Sized_relobj_file object.
1907
  Sized_relobj_file<size, big_endian>*
1908
  sized_relobj()
1909
  { return this; }
1910
 
1911
  const Sized_relobj_file<size, big_endian>*
1912
  sized_relobj() const
1913
  { return this; }
1914
 
1915
  // Return the number of symbols.  This is only valid after
1916
  // Object::add_symbols has been called.
1917
  unsigned int
1918
  symbol_count() const
1919
  { return this->local_symbol_count_ + this->symbols_.size(); }
1920
 
1921
  // If SYM is the index of a global symbol in the object file's
1922
  // symbol table, return the Symbol object.  Otherwise, return NULL.
1923
  Symbol*
1924
  global_symbol(unsigned int sym) const
1925
  {
1926
    if (sym >= this->local_symbol_count_)
1927
      {
1928
        gold_assert(sym - this->local_symbol_count_ < this->symbols_.size());
1929
        return this->symbols_[sym - this->local_symbol_count_];
1930
      }
1931
    return NULL;
1932
  }
1933
 
1934
  // Return the section index of symbol SYM.  Set *VALUE to its value
1935
  // in the object file.  Set *IS_ORDINARY if this is an ordinary
1936
  // section index, not a special code between SHN_LORESERVE and
1937
  // SHN_HIRESERVE.  Note that for a symbol which is not defined in
1938
  // this object file, this will set *VALUE to 0 and return SHN_UNDEF;
1939
  // it will not return the final value of the symbol in the link.
1940
  unsigned int
1941
  symbol_section_and_value(unsigned int sym, Address* value, bool* is_ordinary);
1942
 
1943
  // Return a pointer to the Symbol_value structure which holds the
1944
  // value of a local symbol.
1945
  const Symbol_value<size>*
1946
  local_symbol(unsigned int sym) const
1947
  {
1948
    gold_assert(sym < this->local_values_.size());
1949
    return &this->local_values_[sym];
1950
  }
1951
 
1952
  // Return the index of local symbol SYM in the ordinary symbol
1953
  // table.  A value of -1U means that the symbol is not being output.
1954
  unsigned int
1955
  symtab_index(unsigned int sym) const
1956
  {
1957
    gold_assert(sym < this->local_values_.size());
1958
    return this->local_values_[sym].output_symtab_index();
1959
  }
1960
 
1961
  // Return the index of local symbol SYM in the dynamic symbol
1962
  // table.  A value of -1U means that the symbol is not being output.
1963
  unsigned int
1964
  dynsym_index(unsigned int sym) const
1965
  {
1966
    gold_assert(sym < this->local_values_.size());
1967
    return this->local_values_[sym].output_dynsym_index();
1968
  }
1969
 
1970
  // Return the input section index of local symbol SYM.
1971
  unsigned int
1972
  local_symbol_input_shndx(unsigned int sym, bool* is_ordinary) const
1973
  {
1974
    gold_assert(sym < this->local_values_.size());
1975
    return this->local_values_[sym].input_shndx(is_ordinary);
1976
  }
1977
 
1978
  // Record that local symbol SYM must be in the output symbol table.
1979
  void
1980
  set_must_have_output_symtab_entry(unsigned int sym)
1981
  {
1982
    gold_assert(sym < this->local_values_.size());
1983
    this->local_values_[sym].set_must_have_output_symtab_entry();
1984
  }
1985
 
1986
  // Record that local symbol SYM needs a dynamic symbol entry.
1987
  void
1988
  set_needs_output_dynsym_entry(unsigned int sym)
1989
  {
1990
    gold_assert(sym < this->local_values_.size());
1991
    this->local_values_[sym].set_needs_output_dynsym_entry();
1992
  }
1993
 
1994
  // Return whether the local symbol SYMNDX has a PLT offset.
1995
  bool
1996
  local_has_plt_offset(unsigned int symndx) const;
1997
 
1998
  // Return the PLT offset for a local symbol.  It is an error to call
1999
  // this if it doesn't have one.
2000
  unsigned int
2001
  local_plt_offset(unsigned int symndx) const;
2002
 
2003
  // Set the PLT offset of the local symbol SYMNDX.
2004
  void
2005
  set_local_plt_offset(unsigned int symndx, unsigned int plt_offset);
2006
 
2007
  // Return the name of the symbol that spans the given offset in the
2008
  // specified section in this object.  This is used only for error
2009
  // messages and is not particularly efficient.
2010
  bool
2011
  get_symbol_location_info(unsigned int shndx, off_t offset,
2012
                           Symbol_location_info* info);
2013
 
2014
  // Look for a kept section corresponding to the given discarded section,
2015
  // and return its output address.  This is used only for relocations in
2016
  // debugging sections.
2017
  Address
2018
  map_to_kept_section(unsigned int shndx, bool* found) const;
2019
 
2020
  // Compute final local symbol value.  R_SYM is the local symbol index.
2021
  // LV_IN points to a local symbol value containing the input value.
2022
  // LV_OUT points to a local symbol value storing the final output value,
2023
  // which must not be a merged symbol value since before calling this
2024
  // method to avoid memory leak.  SYMTAB points to a symbol table.
2025
  //
2026
  // The method returns a status code at return.  If the return status is
2027
  // CFLV_OK, *LV_OUT contains the final value.  If the return status is
2028
  // CFLV_ERROR, *LV_OUT is 0.  If the return status is CFLV_DISCARDED,
2029
  // *LV_OUT is not modified.
2030
  Compute_final_local_value_status
2031
  compute_final_local_value(unsigned int r_sym,
2032
                            const Symbol_value<size>* lv_in,
2033
                            Symbol_value<size>* lv_out,
2034
                            const Symbol_table* symtab);
2035
 
2036
 protected:
2037
  typedef typename Sized_relobj<size, big_endian>::Output_sections
2038
      Output_sections;
2039
 
2040
  // Set up.
2041
  virtual void
2042
  do_setup();
2043
 
2044
  // Read the symbols.
2045
  void
2046
  do_read_symbols(Read_symbols_data*);
2047
 
2048
  // Return the number of local symbols.
2049
  unsigned int
2050
  do_local_symbol_count() const
2051
  { return this->local_symbol_count_; }
2052
 
2053
  // Return the number of local symbols in the output symbol table.
2054
  unsigned int
2055
  do_output_local_symbol_count() const
2056
  { return this->output_local_symbol_count_; }
2057
 
2058
  // Return the number of local symbols in the output symbol table.
2059
  off_t
2060
  do_local_symbol_offset() const
2061
  { return this->local_symbol_offset_; }
2062
 
2063
  // Lay out the input sections.
2064
  void
2065
  do_layout(Symbol_table*, Layout*, Read_symbols_data*);
2066
 
2067
  // Layout sections whose layout was deferred while waiting for
2068
  // input files from a plugin.
2069
  void
2070
  do_layout_deferred_sections(Layout*);
2071
 
2072
  // Add the symbols to the symbol table.
2073
  void
2074
  do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
2075
 
2076
  Archive::Should_include
2077
  do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
2078
                           std::string* why);
2079
 
2080
  // Iterate over global symbols, calling a visitor class V for each.
2081
  void
2082
  do_for_all_global_symbols(Read_symbols_data* sd,
2083
                            Library_base::Symbol_visitor_base* v);
2084
 
2085
  // Read the relocs.
2086
  void
2087
  do_read_relocs(Read_relocs_data*);
2088
 
2089
  // Process the relocs to find list of referenced sections. Used only
2090
  // during garbage collection.
2091
  void
2092
  do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*);
2093
 
2094
  // Scan the relocs and adjust the symbol table.
2095
  void
2096
  do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*);
2097
 
2098
  // Count the local symbols.
2099
  void
2100
  do_count_local_symbols(Stringpool_template<char>*,
2101
                            Stringpool_template<char>*);
2102
 
2103
  // Finalize the local symbols.
2104
  unsigned int
2105
  do_finalize_local_symbols(unsigned int, off_t, Symbol_table*);
2106
 
2107
  // Set the offset where local dynamic symbol information will be stored.
2108
  unsigned int
2109
  do_set_local_dynsym_indexes(unsigned int);
2110
 
2111
  // Set the offset where local dynamic symbol information will be stored.
2112
  unsigned int
2113
  do_set_local_dynsym_offset(off_t);
2114
 
2115
  // Relocate the input sections and write out the local symbols.
2116
  void
2117
  do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of);
2118
 
2119
  // Get the size of a section.
2120
  uint64_t
2121
  do_section_size(unsigned int shndx)
2122
  { return this->elf_file_.section_size(shndx); }
2123
 
2124
  // Get the name of a section.
2125
  std::string
2126
  do_section_name(unsigned int shndx)
2127
  { return this->elf_file_.section_name(shndx); }
2128
 
2129
  // Return the location of the contents of a section.
2130
  Object::Location
2131
  do_section_contents(unsigned int shndx)
2132
  { return this->elf_file_.section_contents(shndx); }
2133
 
2134
  // Return section flags.
2135
  uint64_t
2136
  do_section_flags(unsigned int shndx);
2137
 
2138
  // Return section entsize.
2139
  uint64_t
2140
  do_section_entsize(unsigned int shndx);
2141
 
2142
  // Return section address.
2143
  uint64_t
2144
  do_section_address(unsigned int shndx)
2145
  { return this->elf_file_.section_addr(shndx); }
2146
 
2147
  // Return section type.
2148
  unsigned int
2149
  do_section_type(unsigned int shndx)
2150
  { return this->elf_file_.section_type(shndx); }
2151
 
2152
  // Return the section link field.
2153
  unsigned int
2154
  do_section_link(unsigned int shndx)
2155
  { return this->elf_file_.section_link(shndx); }
2156
 
2157
  // Return the section info field.
2158
  unsigned int
2159
  do_section_info(unsigned int shndx)
2160
  { return this->elf_file_.section_info(shndx); }
2161
 
2162
  // Return the section alignment.
2163
  uint64_t
2164
  do_section_addralign(unsigned int shndx)
2165
  { return this->elf_file_.section_addralign(shndx); }
2166
 
2167
  // Return the Xindex structure to use.
2168
  Xindex*
2169
  do_initialize_xindex();
2170
 
2171
  // Get symbol counts.
2172
  void
2173
  do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
2174
 
2175
  // Get the global symbols.
2176
  const Symbols*
2177
  do_get_global_symbols() const
2178
  { return &this->symbols_; }
2179
 
2180
  // Adjust a section index if necessary.
2181
  unsigned int
2182
  adjust_shndx(unsigned int shndx)
2183
  {
2184
    if (shndx >= elfcpp::SHN_LORESERVE)
2185
      shndx += this->elf_file_.large_shndx_offset();
2186
    return shndx;
2187
  }
2188
 
2189
  // Initialize input to output maps for section symbols in merged
2190
  // sections.
2191
  void
2192
  initialize_input_to_output_maps();
2193
 
2194
  // Free the input to output maps for section symbols in merged
2195
  // sections.
2196
  void
2197
  free_input_to_output_maps();
2198
 
2199
  // Return symbol table section index.
2200
  unsigned int
2201
  symtab_shndx() const
2202
  { return this->symtab_shndx_; }
2203
 
2204
  // Allow a child class to access the ELF file.
2205
  elfcpp::Elf_file<size, big_endian, Object>*
2206
  elf_file()
2207
  { return &this->elf_file_; }
2208
 
2209
  // Allow a child class to access the local values.
2210
  Local_values*
2211
  local_values()
2212
  { return &this->local_values_; }
2213
 
2214
  // Views and sizes when relocating.
2215
  struct View_size
2216
  {
2217
    unsigned char* view;
2218
    typename elfcpp::Elf_types<size>::Elf_Addr address;
2219
    off_t offset;
2220
    section_size_type view_size;
2221
    bool is_input_output_view;
2222
    bool is_postprocessing_view;
2223
  };
2224
 
2225
  typedef std::vector<View_size> Views;
2226
 
2227
  // This may be overriden by a child class.
2228
  virtual void
2229
  do_relocate_sections(const Symbol_table* symtab, const Layout* layout,
2230
                       const unsigned char* pshdrs, Output_file* of,
2231
                       Views* pviews);
2232
 
2233
  // Allow a child to set output local symbol count.
2234
  void
2235
  set_output_local_symbol_count(unsigned int value)
2236
  { this->output_local_symbol_count_ = value; }
2237
 
2238
  // Return TRUE if the section is a compressed debug section, and set
2239
  // *UNCOMPRESSED_SIZE to the size of the uncompressed data.
2240
  bool
2241
  do_section_is_compressed(unsigned int shndx,
2242
                           section_size_type* uncompressed_size) const
2243
  {
2244
    if (this->compressed_sections_ == NULL)
2245
      return false;
2246
    Compressed_section_map::const_iterator p =
2247
        this->compressed_sections_->find(shndx);
2248
    if (p != this->compressed_sections_->end())
2249
      {
2250
        if (uncompressed_size != NULL)
2251
          *uncompressed_size = p->second;
2252
        return true;
2253
      }
2254
    return false;
2255
  }
2256
 
2257
 private:
2258
  // For convenience.
2259
  typedef Sized_relobj_file<size, big_endian> This;
2260
  static const int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
2261
  static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2262
  static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
2263
  typedef elfcpp::Shdr<size, big_endian> Shdr;
2264
 
2265
  // To keep track of discarded comdat sections, we need to map a member
2266
  // section index to the object and section index of the corresponding
2267
  // kept section.
2268
  struct Kept_comdat_section
2269
  {
2270
    Kept_comdat_section(Relobj* a_object, unsigned int a_shndx)
2271
      : object(a_object), shndx(a_shndx)
2272
    { }
2273
    Relobj* object;
2274
    unsigned int shndx;
2275
  };
2276
  typedef std::map<unsigned int, Kept_comdat_section>
2277
      Kept_comdat_section_table;
2278
 
2279
  // Find the SHT_SYMTAB section, given the section headers.
2280
  void
2281
  find_symtab(const unsigned char* pshdrs);
2282
 
2283
  // Return whether SHDR has the right flags for a GNU style exception
2284
  // frame section.
2285
  bool
2286
  check_eh_frame_flags(const elfcpp::Shdr<size, big_endian>* shdr) const;
2287
 
2288
  // Return whether there is a section named .eh_frame which might be
2289
  // a GNU style exception frame section.
2290
  bool
2291
  find_eh_frame(const unsigned char* pshdrs, const char* names,
2292
                section_size_type names_size) const;
2293
 
2294
  // Whether to include a section group in the link.
2295
  bool
2296
  include_section_group(Symbol_table*, Layout*, unsigned int, const char*,
2297
                        const unsigned char*, const char*, section_size_type,
2298
                        std::vector<bool>*);
2299
 
2300
  // Whether to include a linkonce section in the link.
2301
  bool
2302
  include_linkonce_section(Layout*, unsigned int, const char*,
2303
                           const elfcpp::Shdr<size, big_endian>&);
2304
 
2305
  // Layout an input section.
2306
  void
2307
  layout_section(Layout* layout, unsigned int shndx, const char* name,
2308
                 typename This::Shdr& shdr, unsigned int reloc_shndx,
2309
                 unsigned int reloc_type);
2310
 
2311
  // Write section data to the output file.  Record the views and
2312
  // sizes in VIEWS for use when relocating.
2313
  void
2314
  write_sections(const unsigned char* pshdrs, Output_file*, Views*);
2315
 
2316
  // Relocate the sections in the output file.
2317
  void
2318
  relocate_sections(const Symbol_table* symtab, const Layout* layout,
2319
                    const unsigned char* pshdrs, Output_file* of,
2320
                    Views* pviews)
2321
  { this->do_relocate_sections(symtab, layout, pshdrs, of, pviews); }
2322
 
2323
  // Scan the input relocations for --emit-relocs.
2324
  void
2325
  emit_relocs_scan(Symbol_table*, Layout*, const unsigned char* plocal_syms,
2326
                   const Read_relocs_data::Relocs_list::iterator&);
2327
 
2328
  // Scan the input relocations for --emit-relocs, templatized on the
2329
  // type of the relocation section.
2330
  template<int sh_type>
2331
  void
2332
  emit_relocs_scan_reltype(Symbol_table*, Layout*,
2333
                           const unsigned char* plocal_syms,
2334
                           const Read_relocs_data::Relocs_list::iterator&,
2335
                           Relocatable_relocs*);
2336
 
2337
  // Emit the relocs for --emit-relocs.
2338
  void
2339
  emit_relocs(const Relocate_info<size, big_endian>*, unsigned int,
2340
              unsigned int sh_type, const unsigned char* prelocs,
2341
              size_t reloc_count, Output_section*, Address output_offset,
2342
              unsigned char* view, Address address,
2343
              section_size_type view_size,
2344
              unsigned char* reloc_view, section_size_type reloc_view_size);
2345
 
2346
  // Emit the relocs for --emit-relocs, templatized on the type of the
2347
  // relocation section.
2348
  template<int sh_type>
2349
  void
2350
  emit_relocs_reltype(const Relocate_info<size, big_endian>*, unsigned int,
2351
                      const unsigned char* prelocs, size_t reloc_count,
2352
                      Output_section*, Address output_offset,
2353
                      unsigned char* view, Address address,
2354
                      section_size_type view_size,
2355
                      unsigned char* reloc_view,
2356
                      section_size_type reloc_view_size);
2357
 
2358
  // Scan the input relocations for --incremental.
2359
  void
2360
  incremental_relocs_scan(const Read_relocs_data::Relocs_list::iterator&);
2361
 
2362
  // Scan the input relocations for --incremental, templatized on the
2363
  // type of the relocation section.
2364
  template<int sh_type>
2365
  void
2366
  incremental_relocs_scan_reltype(
2367
      const Read_relocs_data::Relocs_list::iterator&);
2368
 
2369
  void
2370
  incremental_relocs_write(const Relocate_info<size, big_endian>*,
2371
                           unsigned int sh_type,
2372
                           const unsigned char* prelocs,
2373
                           size_t reloc_count,
2374
                           Output_section*,
2375
                           Address output_offset,
2376
                           Output_file*);
2377
 
2378
  template<int sh_type>
2379
  void
2380
  incremental_relocs_write_reltype(const Relocate_info<size, big_endian>*,
2381
                                   const unsigned char* prelocs,
2382
                                   size_t reloc_count,
2383
                                   Output_section*,
2384
                                   Address output_offset,
2385
                                   Output_file*);
2386
 
2387
  // A type shared by split_stack_adjust_reltype and find_functions.
2388
  typedef std::map<section_offset_type, section_size_type> Function_offsets;
2389
 
2390
  // Check for -fsplit-stack routines calling non-split-stack routines.
2391
  void
2392
  split_stack_adjust(const Symbol_table*, const unsigned char* pshdrs,
2393
                     unsigned int sh_type, unsigned int shndx,
2394
                     const unsigned char* prelocs, size_t reloc_count,
2395
                     unsigned char* view, section_size_type view_size,
2396
                     Reloc_symbol_changes** reloc_map);
2397
 
2398
  template<int sh_type>
2399
  void
2400
  split_stack_adjust_reltype(const Symbol_table*, const unsigned char* pshdrs,
2401
                             unsigned int shndx, const unsigned char* prelocs,
2402
                             size_t reloc_count, unsigned char* view,
2403
                             section_size_type view_size,
2404
                             Reloc_symbol_changes** reloc_map);
2405
 
2406
  // Find all functions in a section.
2407
  void
2408
  find_functions(const unsigned char* pshdrs, unsigned int shndx,
2409
                 Function_offsets*);
2410
 
2411
  // Write out the local symbols.
2412
  void
2413
  write_local_symbols(Output_file*,
2414
                      const Stringpool_template<char>*,
2415
                      const Stringpool_template<char>*,
2416
                      Output_symtab_xindex*,
2417
                      Output_symtab_xindex*,
2418
                      off_t);
2419
 
2420
  // Record a mapping from discarded section SHNDX to the corresponding
2421
  // kept section.
2422
  void
2423
  set_kept_comdat_section(unsigned int shndx, Relobj* kept_object,
2424
                          unsigned int kept_shndx)
2425
  {
2426
    Kept_comdat_section kept(kept_object, kept_shndx);
2427
    this->kept_comdat_sections_.insert(std::make_pair(shndx, kept));
2428
  }
2429
 
2430
  // Find the kept section corresponding to the discarded section
2431
  // SHNDX.  Return true if found.
2432
  bool
2433
  get_kept_comdat_section(unsigned int shndx, Relobj** kept_object,
2434
                          unsigned int* kept_shndx) const
2435
  {
2436
    typename Kept_comdat_section_table::const_iterator p =
2437
      this->kept_comdat_sections_.find(shndx);
2438
    if (p == this->kept_comdat_sections_.end())
2439
      return false;
2440
    *kept_object = p->second.object;
2441
    *kept_shndx = p->second.shndx;
2442
    return true;
2443
  }
2444
 
2445
  // Compute final local symbol value.  R_SYM is the local symbol index.
2446
  // LV_IN points to a local symbol value containing the input value.
2447
  // LV_OUT points to a local symbol value storing the final output value,
2448
  // which must not be a merged symbol value since before calling this
2449
  // method to avoid memory leak.  RELOCATABLE indicates whether we are
2450
  // linking a relocatable output.  OUT_SECTIONS is an array of output
2451
  // sections.  OUT_OFFSETS is an array of offsets of the sections.  SYMTAB
2452
  // points to a symbol table.
2453
  //
2454
  // The method returns a status code at return.  If the return status is
2455
  // CFLV_OK, *LV_OUT contains the final value.  If the return status is
2456
  // CFLV_ERROR, *LV_OUT is 0.  If the return status is CFLV_DISCARDED,
2457
  // *LV_OUT is not modified.
2458
  inline Compute_final_local_value_status
2459
  compute_final_local_value_internal(unsigned int r_sym,
2460
                                     const Symbol_value<size>* lv_in,
2461
                                     Symbol_value<size>* lv_out,
2462
                                     bool relocatable,
2463
                                     const Output_sections& out_sections,
2464
                                     const std::vector<Address>& out_offsets,
2465
                                     const Symbol_table* symtab);
2466
 
2467
  // The PLT offsets of local symbols.
2468
  typedef Unordered_map<unsigned int, unsigned int> Local_plt_offsets;
2469
 
2470
  // Saved information for sections whose layout was deferred.
2471
  struct Deferred_layout
2472
  {
2473
    static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2474
    Deferred_layout(unsigned int shndx, const char* name,
2475
                    const unsigned char* pshdr,
2476
                    unsigned int reloc_shndx, unsigned int reloc_type)
2477
      : shndx_(shndx), name_(name), reloc_shndx_(reloc_shndx),
2478
        reloc_type_(reloc_type)
2479
    {
2480
      memcpy(this->shdr_data_, pshdr, shdr_size);
2481
    }
2482
    unsigned int shndx_;
2483
    std::string name_;
2484
    unsigned int reloc_shndx_;
2485
    unsigned int reloc_type_;
2486
    unsigned char shdr_data_[shdr_size];
2487
  };
2488
 
2489
  // General access to the ELF file.
2490
  elfcpp::Elf_file<size, big_endian, Object> elf_file_;
2491
  // Index of SHT_SYMTAB section.
2492
  unsigned int symtab_shndx_;
2493
  // The number of local symbols.
2494
  unsigned int local_symbol_count_;
2495
  // The number of local symbols which go into the output file.
2496
  unsigned int output_local_symbol_count_;
2497
  // The number of local symbols which go into the output file's dynamic
2498
  // symbol table.
2499
  unsigned int output_local_dynsym_count_;
2500
  // The entries in the symbol table for the external symbols.
2501
  Symbols symbols_;
2502
  // Number of symbols defined in object file itself.
2503
  size_t defined_count_;
2504
  // File offset for local symbols (relative to start of symbol table).
2505
  off_t local_symbol_offset_;
2506
  // File offset for local dynamic symbols (absolute).
2507
  off_t local_dynsym_offset_;
2508
  // Values of local symbols.
2509
  Local_values local_values_;
2510
  // PLT offsets for local symbols.
2511
  Local_plt_offsets local_plt_offsets_;
2512
  // Table mapping discarded comdat sections to corresponding kept sections.
2513
  Kept_comdat_section_table kept_comdat_sections_;
2514
  // Whether this object has a GNU style .eh_frame section.
2515
  bool has_eh_frame_;
2516
  // If this object has a GNU style .eh_frame section that is discarded in
2517
  // output, record the index here.  Otherwise it is -1U.
2518
  unsigned int discarded_eh_frame_shndx_;
2519
  // The list of sections whose layout was deferred.
2520
  std::vector<Deferred_layout> deferred_layout_;
2521
  // The list of relocation sections whose layout was deferred.
2522
  std::vector<Deferred_layout> deferred_layout_relocs_;
2523
  // For compressed debug sections, map section index to uncompressed size.
2524
  Compressed_section_map* compressed_sections_;
2525
};
2526
 
2527
// A class to manage the list of all objects.
2528
 
2529
class Input_objects
2530
{
2531
 public:
2532
  Input_objects()
2533
    : relobj_list_(), dynobj_list_(), sonames_(), cref_(NULL)
2534
  { }
2535
 
2536
  // The type of the list of input relocateable objects.
2537
  typedef std::vector<Relobj*> Relobj_list;
2538
  typedef Relobj_list::const_iterator Relobj_iterator;
2539
 
2540
  // The type of the list of input dynamic objects.
2541
  typedef std::vector<Dynobj*> Dynobj_list;
2542
  typedef Dynobj_list::const_iterator Dynobj_iterator;
2543
 
2544
  // Add an object to the list.  Return true if all is well, or false
2545
  // if this object should be ignored.
2546
  bool
2547
  add_object(Object*);
2548
 
2549
  // Start processing an archive.
2550
  void
2551
  archive_start(Archive*);
2552
 
2553
  // Stop processing an archive.
2554
  void
2555
  archive_stop(Archive*);
2556
 
2557
  // For each dynamic object, check whether we've seen all of its
2558
  // explicit dependencies.
2559
  void
2560
  check_dynamic_dependencies() const;
2561
 
2562
  // Return whether an object was found in the system library
2563
  // directory.
2564
  bool
2565
  found_in_system_library_directory(const Object*) const;
2566
 
2567
  // Print symbol counts.
2568
  void
2569
  print_symbol_counts(const Symbol_table*) const;
2570
 
2571
  // Print a cross reference table.
2572
  void
2573
  print_cref(const Symbol_table*, FILE*) const;
2574
 
2575
  // Iterate over all regular objects.
2576
 
2577
  Relobj_iterator
2578
  relobj_begin() const
2579
  { return this->relobj_list_.begin(); }
2580
 
2581
  Relobj_iterator
2582
  relobj_end() const
2583
  { return this->relobj_list_.end(); }
2584
 
2585
  // Iterate over all dynamic objects.
2586
 
2587
  Dynobj_iterator
2588
  dynobj_begin() const
2589
  { return this->dynobj_list_.begin(); }
2590
 
2591
  Dynobj_iterator
2592
  dynobj_end() const
2593
  { return this->dynobj_list_.end(); }
2594
 
2595
  // Return whether we have seen any dynamic objects.
2596
  bool
2597
  any_dynamic() const
2598
  { return !this->dynobj_list_.empty(); }
2599
 
2600
  // Return the number of non dynamic objects.
2601
  int
2602
  number_of_relobjs() const
2603
  { return this->relobj_list_.size(); }
2604
 
2605
  // Return the number of input objects.
2606
  int
2607
  number_of_input_objects() const
2608
  { return this->relobj_list_.size() + this->dynobj_list_.size(); }
2609
 
2610
 private:
2611
  Input_objects(const Input_objects&);
2612
  Input_objects& operator=(const Input_objects&);
2613
 
2614
  // The list of ordinary objects included in the link.
2615
  Relobj_list relobj_list_;
2616
  // The list of dynamic objects included in the link.
2617
  Dynobj_list dynobj_list_;
2618
  // SONAMEs that we have seen.
2619
  Unordered_set<std::string> sonames_;
2620
  // Manage cross-references if requested.
2621
  Cref* cref_;
2622
};
2623
 
2624
// Some of the information we pass to the relocation routines.  We
2625
// group this together to avoid passing a dozen different arguments.
2626
 
2627
template<int size, bool big_endian>
2628
struct Relocate_info
2629
{
2630
  // Symbol table.
2631
  const Symbol_table* symtab;
2632
  // Layout.
2633
  const Layout* layout;
2634
  // Object being relocated.
2635
  Sized_relobj_file<size, big_endian>* object;
2636
  // Section index of relocation section.
2637
  unsigned int reloc_shndx;
2638
  // Section header of relocation section.
2639
  const unsigned char* reloc_shdr;
2640
  // Section index of section being relocated.
2641
  unsigned int data_shndx;
2642
  // Section header of data section.
2643
  const unsigned char* data_shdr;
2644
 
2645
  // Return a string showing the location of a relocation.  This is
2646
  // only used for error messages.
2647
  std::string
2648
  location(size_t relnum, off_t reloffset) const;
2649
};
2650
 
2651
// This is used to represent a section in an object and is used as the
2652
// key type for various section maps.
2653
typedef std::pair<Object*, unsigned int> Section_id;
2654
 
2655
// This is similar to Section_id but is used when the section
2656
// pointers are const.
2657
typedef std::pair<const Object*, unsigned int> Const_section_id;
2658
 
2659
// The hash value is based on the address of an object in memory during
2660
// linking.  It is okay to use this for looking up sections but never use
2661
// this in an unordered container that we want to traverse in a repeatable
2662
// manner.
2663
 
2664
struct Section_id_hash
2665
{
2666
  size_t operator()(const Section_id& loc) const
2667
  { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; }
2668
};
2669
 
2670
struct Const_section_id_hash
2671
{
2672
  size_t operator()(const Const_section_id& loc) const
2673
  { return reinterpret_cast<uintptr_t>(loc.first) ^ loc.second; }
2674
};
2675
 
2676
// Return whether INPUT_FILE contains an ELF object start at file
2677
// offset OFFSET.  This sets *START to point to a view of the start of
2678
// the file.  It sets *READ_SIZE to the number of bytes in the view.
2679
 
2680
extern bool
2681
is_elf_object(Input_file* input_file, off_t offset,
2682
              const unsigned char** start, int* read_size);
2683
 
2684
// Return an Object appropriate for the input file.  P is BYTES long,
2685
// and holds the ELF header.  If PUNCONFIGURED is not NULL, then if
2686
// this sees an object the linker is not configured to support, it
2687
// sets *PUNCONFIGURED to true and returns NULL without giving an
2688
// error message.
2689
 
2690
extern Object*
2691
make_elf_object(const std::string& name, Input_file*,
2692
                off_t offset, const unsigned char* p,
2693
                section_offset_type bytes, bool* punconfigured);
2694
 
2695
} // end namespace gold
2696
 
2697
#endif // !defined(GOLD_OBJECT_H)

powered by: WebSVN 2.1.0

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