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

Subversion Repositories open8_urisc

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

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

Line No. Rev Author Line
1 27 khays
// object.cc -- support for an object file for linking in gold
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
#include "gold.h"
24
 
25
#include <cerrno>
26
#include <cstring>
27
#include <cstdarg>
28
#include "demangle.h"
29
#include "libiberty.h"
30
 
31
#include "gc.h"
32
#include "target-select.h"
33
#include "dwarf_reader.h"
34
#include "layout.h"
35
#include "output.h"
36
#include "symtab.h"
37
#include "cref.h"
38
#include "reloc.h"
39
#include "object.h"
40
#include "dynobj.h"
41
#include "plugin.h"
42
#include "compressed_output.h"
43
#include "incremental.h"
44
 
45
namespace gold
46
{
47
 
48
// Struct Read_symbols_data.
49
 
50
// Destroy any remaining File_view objects.
51
 
52
Read_symbols_data::~Read_symbols_data()
53
{
54
  if (this->section_headers != NULL)
55
    delete this->section_headers;
56
  if (this->section_names != NULL)
57
    delete this->section_names;
58
  if (this->symbols != NULL)
59
    delete this->symbols;
60
  if (this->symbol_names != NULL)
61
    delete this->symbol_names;
62
  if (this->versym != NULL)
63
    delete this->versym;
64
  if (this->verdef != NULL)
65
    delete this->verdef;
66
  if (this->verneed != NULL)
67
    delete this->verneed;
68
}
69
 
70
// Class Xindex.
71
 
72
// Initialize the symtab_xindex_ array.  Find the SHT_SYMTAB_SHNDX
73
// section and read it in.  SYMTAB_SHNDX is the index of the symbol
74
// table we care about.
75
 
76
template<int size, bool big_endian>
77
void
78
Xindex::initialize_symtab_xindex(Object* object, unsigned int symtab_shndx)
79
{
80
  if (!this->symtab_xindex_.empty())
81
    return;
82
 
83
  gold_assert(symtab_shndx != 0);
84
 
85
  // Look through the sections in reverse order, on the theory that it
86
  // is more likely to be near the end than the beginning.
87
  unsigned int i = object->shnum();
88
  while (i > 0)
89
    {
90
      --i;
91
      if (object->section_type(i) == elfcpp::SHT_SYMTAB_SHNDX
92
          && this->adjust_shndx(object->section_link(i)) == symtab_shndx)
93
        {
94
          this->read_symtab_xindex<size, big_endian>(object, i, NULL);
95
          return;
96
        }
97
    }
98
 
99
  object->error(_("missing SHT_SYMTAB_SHNDX section"));
100
}
101
 
102
// Read in the symtab_xindex_ array, given the section index of the
103
// SHT_SYMTAB_SHNDX section.  If PSHDRS is not NULL, it points at the
104
// section headers.
105
 
106
template<int size, bool big_endian>
107
void
108
Xindex::read_symtab_xindex(Object* object, unsigned int xindex_shndx,
109
                           const unsigned char* pshdrs)
110
{
111
  section_size_type bytecount;
112
  const unsigned char* contents;
113
  if (pshdrs == NULL)
114
    contents = object->section_contents(xindex_shndx, &bytecount, false);
115
  else
116
    {
117
      const unsigned char* p = (pshdrs
118
                                + (xindex_shndx
119
                                   * elfcpp::Elf_sizes<size>::shdr_size));
120
      typename elfcpp::Shdr<size, big_endian> shdr(p);
121
      bytecount = convert_to_section_size_type(shdr.get_sh_size());
122
      contents = object->get_view(shdr.get_sh_offset(), bytecount, true, false);
123
    }
124
 
125
  gold_assert(this->symtab_xindex_.empty());
126
  this->symtab_xindex_.reserve(bytecount / 4);
127
  for (section_size_type i = 0; i < bytecount; i += 4)
128
    {
129
      unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(contents + i);
130
      // We preadjust the section indexes we save.
131
      this->symtab_xindex_.push_back(this->adjust_shndx(shndx));
132
    }
133
}
134
 
135
// Symbol symndx has a section of SHN_XINDEX; return the real section
136
// index.
137
 
138
unsigned int
139
Xindex::sym_xindex_to_shndx(Object* object, unsigned int symndx)
140
{
141
  if (symndx >= this->symtab_xindex_.size())
142
    {
143
      object->error(_("symbol %u out of range for SHT_SYMTAB_SHNDX section"),
144
                    symndx);
145
      return elfcpp::SHN_UNDEF;
146
    }
147
  unsigned int shndx = this->symtab_xindex_[symndx];
148
  if (shndx < elfcpp::SHN_LORESERVE || shndx >= object->shnum())
149
    {
150
      object->error(_("extended index for symbol %u out of range: %u"),
151
                    symndx, shndx);
152
      return elfcpp::SHN_UNDEF;
153
    }
154
  return shndx;
155
}
156
 
157
// Class Object.
158
 
159
// Report an error for this object file.  This is used by the
160
// elfcpp::Elf_file interface, and also called by the Object code
161
// itself.
162
 
163
void
164
Object::error(const char* format, ...) const
165
{
166
  va_list args;
167
  va_start(args, format);
168
  char* buf = NULL;
169
  if (vasprintf(&buf, format, args) < 0)
170
    gold_nomem();
171
  va_end(args);
172
  gold_error(_("%s: %s"), this->name().c_str(), buf);
173
  free(buf);
174
}
175
 
176
// Return a view of the contents of a section.
177
 
178
const unsigned char*
179
Object::section_contents(unsigned int shndx, section_size_type* plen,
180
                         bool cache)
181
{
182
  Location loc(this->do_section_contents(shndx));
183
  *plen = convert_to_section_size_type(loc.data_size);
184
  if (*plen == 0)
185
    {
186
      static const unsigned char empty[1] = { '\0' };
187
      return empty;
188
    }
189
  return this->get_view(loc.file_offset, *plen, true, cache);
190
}
191
 
192
// Read the section data into SD.  This is code common to Sized_relobj_file
193
// and Sized_dynobj, so we put it into Object.
194
 
195
template<int size, bool big_endian>
196
void
197
Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file,
198
                          Read_symbols_data* sd)
199
{
200
  const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
201
 
202
  // Read the section headers.
203
  const off_t shoff = elf_file->shoff();
204
  const unsigned int shnum = this->shnum();
205
  sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size,
206
                                               true, true);
207
 
208
  // Read the section names.
209
  const unsigned char* pshdrs = sd->section_headers->data();
210
  const unsigned char* pshdrnames = pshdrs + elf_file->shstrndx() * shdr_size;
211
  typename elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
212
 
213
  if (shdrnames.get_sh_type() != elfcpp::SHT_STRTAB)
214
    this->error(_("section name section has wrong type: %u"),
215
                static_cast<unsigned int>(shdrnames.get_sh_type()));
216
 
217
  sd->section_names_size =
218
    convert_to_section_size_type(shdrnames.get_sh_size());
219
  sd->section_names = this->get_lasting_view(shdrnames.get_sh_offset(),
220
                                             sd->section_names_size, false,
221
                                             false);
222
}
223
 
224
// If NAME is the name of a special .gnu.warning section, arrange for
225
// the warning to be issued.  SHNDX is the section index.  Return
226
// whether it is a warning section.
227
 
228
bool
229
Object::handle_gnu_warning_section(const char* name, unsigned int shndx,
230
                                   Symbol_table* symtab)
231
{
232
  const char warn_prefix[] = ".gnu.warning.";
233
  const int warn_prefix_len = sizeof warn_prefix - 1;
234
  if (strncmp(name, warn_prefix, warn_prefix_len) == 0)
235
    {
236
      // Read the section contents to get the warning text.  It would
237
      // be nicer if we only did this if we have to actually issue a
238
      // warning.  Unfortunately, warnings are issued as we relocate
239
      // sections.  That means that we can not lock the object then,
240
      // as we might try to issue the same warning multiple times
241
      // simultaneously.
242
      section_size_type len;
243
      const unsigned char* contents = this->section_contents(shndx, &len,
244
                                                             false);
245
      if (len == 0)
246
        {
247
          const char* warning = name + warn_prefix_len;
248
          contents = reinterpret_cast<const unsigned char*>(warning);
249
          len = strlen(warning);
250
        }
251
      std::string warning(reinterpret_cast<const char*>(contents), len);
252
      symtab->add_warning(name + warn_prefix_len, this, warning);
253
      return true;
254
    }
255
  return false;
256
}
257
 
258
// If NAME is the name of the special section which indicates that
259
// this object was compiled with -fsplit-stack, mark it accordingly.
260
 
261
bool
262
Object::handle_split_stack_section(const char* name)
263
{
264
  if (strcmp(name, ".note.GNU-split-stack") == 0)
265
    {
266
      this->uses_split_stack_ = true;
267
      return true;
268
    }
269
  if (strcmp(name, ".note.GNU-no-split-stack") == 0)
270
    {
271
      this->has_no_split_stack_ = true;
272
      return true;
273
    }
274
  return false;
275
}
276
 
277
// Class Relobj
278
 
279
// To copy the symbols data read from the file to a local data structure.
280
// This function is called from do_layout only while doing garbage 
281
// collection.
282
 
283
void
284
Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
285
                          unsigned int section_header_size)
286
{
287
  gc_sd->section_headers_data =
288
         new unsigned char[(section_header_size)];
289
  memcpy(gc_sd->section_headers_data, sd->section_headers->data(),
290
         section_header_size);
291
  gc_sd->section_names_data =
292
         new unsigned char[sd->section_names_size];
293
  memcpy(gc_sd->section_names_data, sd->section_names->data(),
294
         sd->section_names_size);
295
  gc_sd->section_names_size = sd->section_names_size;
296
  if (sd->symbols != NULL)
297
    {
298
      gc_sd->symbols_data =
299
             new unsigned char[sd->symbols_size];
300
      memcpy(gc_sd->symbols_data, sd->symbols->data(),
301
            sd->symbols_size);
302
    }
303
  else
304
    {
305
      gc_sd->symbols_data = NULL;
306
    }
307
  gc_sd->symbols_size = sd->symbols_size;
308
  gc_sd->external_symbols_offset = sd->external_symbols_offset;
309
  if (sd->symbol_names != NULL)
310
    {
311
      gc_sd->symbol_names_data =
312
             new unsigned char[sd->symbol_names_size];
313
      memcpy(gc_sd->symbol_names_data, sd->symbol_names->data(),
314
            sd->symbol_names_size);
315
    }
316
  else
317
    {
318
      gc_sd->symbol_names_data = NULL;
319
    }
320
  gc_sd->symbol_names_size = sd->symbol_names_size;
321
}
322
 
323
// This function determines if a particular section name must be included
324
// in the link.  This is used during garbage collection to determine the
325
// roots of the worklist.
326
 
327
bool
328
Relobj::is_section_name_included(const char* name)
329
{
330
  if (is_prefix_of(".ctors", name)
331
      || is_prefix_of(".dtors", name)
332
      || is_prefix_of(".note", name)
333
      || is_prefix_of(".init", name)
334
      || is_prefix_of(".fini", name)
335
      || is_prefix_of(".gcc_except_table", name)
336
      || is_prefix_of(".jcr", name)
337
      || is_prefix_of(".preinit_array", name)
338
      || (is_prefix_of(".text", name)
339
          && strstr(name, "personality"))
340
      || (is_prefix_of(".data", name)
341
          &&  strstr(name, "personality"))
342
      || (is_prefix_of(".gnu.linkonce.d", name)
343
          && strstr(name, "personality")))
344
    {
345
      return true;
346
    }
347
  return false;
348
}
349
 
350
// Finalize the incremental relocation information.  Allocates a block
351
// of relocation entries for each symbol, and sets the reloc_bases_
352
// array to point to the first entry in each block.  If CLEAR_COUNTS
353
// is TRUE, also clear the per-symbol relocation counters.
354
 
355
void
356
Relobj::finalize_incremental_relocs(Layout* layout, bool clear_counts)
357
{
358
  unsigned int nsyms = this->get_global_symbols()->size();
359
  this->reloc_bases_ = new unsigned int[nsyms];
360
 
361
  gold_assert(this->reloc_bases_ != NULL);
362
  gold_assert(layout->incremental_inputs() != NULL);
363
 
364
  unsigned int rindex = layout->incremental_inputs()->get_reloc_count();
365
  for (unsigned int i = 0; i < nsyms; ++i)
366
    {
367
      this->reloc_bases_[i] = rindex;
368
      rindex += this->reloc_counts_[i];
369
      if (clear_counts)
370
        this->reloc_counts_[i] = 0;
371
    }
372
  layout->incremental_inputs()->set_reloc_count(rindex);
373
}
374
 
375
// Class Sized_relobj.
376
 
377
// Iterate over local symbols, calling a visitor class V for each GOT offset
378
// associated with a local symbol.
379
 
380
template<int size, bool big_endian>
381
void
382
Sized_relobj<size, big_endian>::do_for_all_local_got_entries(
383
    Got_offset_list::Visitor* v) const
384
{
385
  unsigned int nsyms = this->local_symbol_count();
386
  for (unsigned int i = 0; i < nsyms; i++)
387
    {
388
      Local_got_offsets::const_iterator p = this->local_got_offsets_.find(i);
389
      if (p != this->local_got_offsets_.end())
390
        {
391
          const Got_offset_list* got_offsets = p->second;
392
          got_offsets->for_all_got_offsets(v);
393
        }
394
    }
395
}
396
 
397
// Class Sized_relobj_file.
398
 
399
template<int size, bool big_endian>
400
Sized_relobj_file<size, big_endian>::Sized_relobj_file(
401
    const std::string& name,
402
    Input_file* input_file,
403
    off_t offset,
404
    const elfcpp::Ehdr<size, big_endian>& ehdr)
405
  : Sized_relobj<size, big_endian>(name, input_file, offset),
406
    elf_file_(this, ehdr),
407
    symtab_shndx_(-1U),
408
    local_symbol_count_(0),
409
    output_local_symbol_count_(0),
410
    output_local_dynsym_count_(0),
411
    symbols_(),
412
    defined_count_(0),
413
    local_symbol_offset_(0),
414
    local_dynsym_offset_(0),
415
    local_values_(),
416
    local_plt_offsets_(),
417
    kept_comdat_sections_(),
418
    has_eh_frame_(false),
419
    discarded_eh_frame_shndx_(-1U),
420
    deferred_layout_(),
421
    deferred_layout_relocs_(),
422
    compressed_sections_()
423
{
424
}
425
 
426
template<int size, bool big_endian>
427
Sized_relobj_file<size, big_endian>::~Sized_relobj_file()
428
{
429
}
430
 
431
// Set up an object file based on the file header.  This sets up the
432
// section information.
433
 
434
template<int size, bool big_endian>
435
void
436
Sized_relobj_file<size, big_endian>::do_setup()
437
{
438
  const unsigned int shnum = this->elf_file_.shnum();
439
  this->set_shnum(shnum);
440
}
441
 
442
// Find the SHT_SYMTAB section, given the section headers.  The ELF
443
// standard says that maybe in the future there can be more than one
444
// SHT_SYMTAB section.  Until somebody figures out how that could
445
// work, we assume there is only one.
446
 
447
template<int size, bool big_endian>
448
void
449
Sized_relobj_file<size, big_endian>::find_symtab(const unsigned char* pshdrs)
450
{
451
  const unsigned int shnum = this->shnum();
452
  this->symtab_shndx_ = 0;
453
  if (shnum > 0)
454
    {
455
      // Look through the sections in reverse order, since gas tends
456
      // to put the symbol table at the end.
457
      const unsigned char* p = pshdrs + shnum * This::shdr_size;
458
      unsigned int i = shnum;
459
      unsigned int xindex_shndx = 0;
460
      unsigned int xindex_link = 0;
461
      while (i > 0)
462
        {
463
          --i;
464
          p -= This::shdr_size;
465
          typename This::Shdr shdr(p);
466
          if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
467
            {
468
              this->symtab_shndx_ = i;
469
              if (xindex_shndx > 0 && xindex_link == i)
470
                {
471
                  Xindex* xindex =
472
                    new Xindex(this->elf_file_.large_shndx_offset());
473
                  xindex->read_symtab_xindex<size, big_endian>(this,
474
                                                               xindex_shndx,
475
                                                               pshdrs);
476
                  this->set_xindex(xindex);
477
                }
478
              break;
479
            }
480
 
481
          // Try to pick up the SHT_SYMTAB_SHNDX section, if there is
482
          // one.  This will work if it follows the SHT_SYMTAB
483
          // section.
484
          if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB_SHNDX)
485
            {
486
              xindex_shndx = i;
487
              xindex_link = this->adjust_shndx(shdr.get_sh_link());
488
            }
489
        }
490
    }
491
}
492
 
493
// Return the Xindex structure to use for object with lots of
494
// sections.
495
 
496
template<int size, bool big_endian>
497
Xindex*
498
Sized_relobj_file<size, big_endian>::do_initialize_xindex()
499
{
500
  gold_assert(this->symtab_shndx_ != -1U);
501
  Xindex* xindex = new Xindex(this->elf_file_.large_shndx_offset());
502
  xindex->initialize_symtab_xindex<size, big_endian>(this, this->symtab_shndx_);
503
  return xindex;
504
}
505
 
506
// Return whether SHDR has the right type and flags to be a GNU
507
// .eh_frame section.
508
 
509
template<int size, bool big_endian>
510
bool
511
Sized_relobj_file<size, big_endian>::check_eh_frame_flags(
512
    const elfcpp::Shdr<size, big_endian>* shdr) const
513
{
514
  return (shdr->get_sh_type() == elfcpp::SHT_PROGBITS
515
          && (shdr->get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
516
}
517
 
518
// Return whether there is a GNU .eh_frame section, given the section
519
// headers and the section names.
520
 
521
template<int size, bool big_endian>
522
bool
523
Sized_relobj_file<size, big_endian>::find_eh_frame(
524
    const unsigned char* pshdrs,
525
    const char* names,
526
    section_size_type names_size) const
527
{
528
  const unsigned int shnum = this->shnum();
529
  const unsigned char* p = pshdrs + This::shdr_size;
530
  for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
531
    {
532
      typename This::Shdr shdr(p);
533
      if (this->check_eh_frame_flags(&shdr))
534
        {
535
          if (shdr.get_sh_name() >= names_size)
536
            {
537
              this->error(_("bad section name offset for section %u: %lu"),
538
                          i, static_cast<unsigned long>(shdr.get_sh_name()));
539
              continue;
540
            }
541
 
542
          const char* name = names + shdr.get_sh_name();
543
          if (strcmp(name, ".eh_frame") == 0)
544
            return true;
545
        }
546
    }
547
  return false;
548
}
549
 
550
// Build a table for any compressed debug sections, mapping each section index
551
// to the uncompressed size.
552
 
553
template<int size, bool big_endian>
554
Compressed_section_map*
555
build_compressed_section_map(
556
    const unsigned char* pshdrs,
557
    unsigned int shnum,
558
    const char* names,
559
    section_size_type names_size,
560
    Sized_relobj_file<size, big_endian>* obj)
561
{
562
  Compressed_section_map* uncompressed_sizes = new Compressed_section_map();
563
  const unsigned int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
564
  const unsigned char* p = pshdrs + shdr_size;
565
  for (unsigned int i = 1; i < shnum; ++i, p += shdr_size)
566
    {
567
      typename elfcpp::Shdr<size, big_endian> shdr(p);
568
      if (shdr.get_sh_type() == elfcpp::SHT_PROGBITS
569
          && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
570
        {
571
          if (shdr.get_sh_name() >= names_size)
572
            {
573
              obj->error(_("bad section name offset for section %u: %lu"),
574
                         i, static_cast<unsigned long>(shdr.get_sh_name()));
575
              continue;
576
            }
577
 
578
          const char* name = names + shdr.get_sh_name();
579
          if (is_compressed_debug_section(name))
580
            {
581
              section_size_type len;
582
              const unsigned char* contents =
583
                  obj->section_contents(i, &len, false);
584
              uint64_t uncompressed_size = get_uncompressed_size(contents, len);
585
              if (uncompressed_size != -1ULL)
586
                (*uncompressed_sizes)[i] =
587
                    convert_to_section_size_type(uncompressed_size);
588
            }
589
        }
590
    }
591
  return uncompressed_sizes;
592
}
593
 
594
// Read the sections and symbols from an object file.
595
 
596
template<int size, bool big_endian>
597
void
598
Sized_relobj_file<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
599
{
600
  this->read_section_data(&this->elf_file_, sd);
601
 
602
  const unsigned char* const pshdrs = sd->section_headers->data();
603
 
604
  this->find_symtab(pshdrs);
605
 
606
  const unsigned char* namesu = sd->section_names->data();
607
  const char* names = reinterpret_cast<const char*>(namesu);
608
  if (memmem(names, sd->section_names_size, ".eh_frame", 10) != NULL)
609
    {
610
      if (this->find_eh_frame(pshdrs, names, sd->section_names_size))
611
        this->has_eh_frame_ = true;
612
    }
613
  if (memmem(names, sd->section_names_size, ".zdebug_", 8) != NULL)
614
    this->compressed_sections_ =
615
        build_compressed_section_map(pshdrs, this->shnum(), names,
616
                                     sd->section_names_size, this);
617
 
618
  sd->symbols = NULL;
619
  sd->symbols_size = 0;
620
  sd->external_symbols_offset = 0;
621
  sd->symbol_names = NULL;
622
  sd->symbol_names_size = 0;
623
 
624
  if (this->symtab_shndx_ == 0)
625
    {
626
      // No symbol table.  Weird but legal.
627
      return;
628
    }
629
 
630
  // Get the symbol table section header.
631
  typename This::Shdr symtabshdr(pshdrs
632
                                 + this->symtab_shndx_ * This::shdr_size);
633
  gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
634
 
635
  // If this object has a .eh_frame section, we need all the symbols.
636
  // Otherwise we only need the external symbols.  While it would be
637
  // simpler to just always read all the symbols, I've seen object
638
  // files with well over 2000 local symbols, which for a 64-bit
639
  // object file format is over 5 pages that we don't need to read
640
  // now.
641
 
642
  const int sym_size = This::sym_size;
643
  const unsigned int loccount = symtabshdr.get_sh_info();
644
  this->local_symbol_count_ = loccount;
645
  this->local_values_.resize(loccount);
646
  section_offset_type locsize = loccount * sym_size;
647
  off_t dataoff = symtabshdr.get_sh_offset();
648
  section_size_type datasize =
649
    convert_to_section_size_type(symtabshdr.get_sh_size());
650
  off_t extoff = dataoff + locsize;
651
  section_size_type extsize = datasize - locsize;
652
 
653
  off_t readoff = this->has_eh_frame_ ? dataoff : extoff;
654
  section_size_type readsize = this->has_eh_frame_ ? datasize : extsize;
655
 
656
  if (readsize == 0)
657
    {
658
      // No external symbols.  Also weird but also legal.
659
      return;
660
    }
661
 
662
  File_view* fvsymtab = this->get_lasting_view(readoff, readsize, true, false);
663
 
664
  // Read the section header for the symbol names.
665
  unsigned int strtab_shndx = this->adjust_shndx(symtabshdr.get_sh_link());
666
  if (strtab_shndx >= this->shnum())
667
    {
668
      this->error(_("invalid symbol table name index: %u"), strtab_shndx);
669
      return;
670
    }
671
  typename This::Shdr strtabshdr(pshdrs + strtab_shndx * This::shdr_size);
672
  if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
673
    {
674
      this->error(_("symbol table name section has wrong type: %u"),
675
                  static_cast<unsigned int>(strtabshdr.get_sh_type()));
676
      return;
677
    }
678
 
679
  // Read the symbol names.
680
  File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
681
                                               strtabshdr.get_sh_size(),
682
                                               false, true);
683
 
684
  sd->symbols = fvsymtab;
685
  sd->symbols_size = readsize;
686
  sd->external_symbols_offset = this->has_eh_frame_ ? locsize : 0;
687
  sd->symbol_names = fvstrtab;
688
  sd->symbol_names_size =
689
    convert_to_section_size_type(strtabshdr.get_sh_size());
690
}
691
 
692
// Return the section index of symbol SYM.  Set *VALUE to its value in
693
// the object file.  Set *IS_ORDINARY if this is an ordinary section
694
// index, not a special code between SHN_LORESERVE and SHN_HIRESERVE.
695
// Note that for a symbol which is not defined in this object file,
696
// this will set *VALUE to 0 and return SHN_UNDEF; it will not return
697
// the final value of the symbol in the link.
698
 
699
template<int size, bool big_endian>
700
unsigned int
701
Sized_relobj_file<size, big_endian>::symbol_section_and_value(unsigned int sym,
702
                                                              Address* value,
703
                                                              bool* is_ordinary)
704
{
705
  section_size_type symbols_size;
706
  const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
707
                                                        &symbols_size,
708
                                                        false);
709
 
710
  const size_t count = symbols_size / This::sym_size;
711
  gold_assert(sym < count);
712
 
713
  elfcpp::Sym<size, big_endian> elfsym(symbols + sym * This::sym_size);
714
  *value = elfsym.get_st_value();
715
 
716
  return this->adjust_sym_shndx(sym, elfsym.get_st_shndx(), is_ordinary);
717
}
718
 
719
// Return whether to include a section group in the link.  LAYOUT is
720
// used to keep track of which section groups we have already seen.
721
// INDEX is the index of the section group and SHDR is the section
722
// header.  If we do not want to include this group, we set bits in
723
// OMIT for each section which should be discarded.
724
 
725
template<int size, bool big_endian>
726
bool
727
Sized_relobj_file<size, big_endian>::include_section_group(
728
    Symbol_table* symtab,
729
    Layout* layout,
730
    unsigned int index,
731
    const char* name,
732
    const unsigned char* shdrs,
733
    const char* section_names,
734
    section_size_type section_names_size,
735
    std::vector<bool>* omit)
736
{
737
  // Read the section contents.
738
  typename This::Shdr shdr(shdrs + index * This::shdr_size);
739
  const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
740
                                             shdr.get_sh_size(), true, false);
741
  const elfcpp::Elf_Word* pword =
742
    reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
743
 
744
  // The first word contains flags.  We only care about COMDAT section
745
  // groups.  Other section groups are always included in the link
746
  // just like ordinary sections.
747
  elfcpp::Elf_Word flags = elfcpp::Swap<32, big_endian>::readval(pword);
748
 
749
  // Look up the group signature, which is the name of a symbol.  This
750
  // is a lot of effort to go to to read a string.  Why didn't they
751
  // just have the group signature point into the string table, rather
752
  // than indirect through a symbol?
753
 
754
  // Get the appropriate symbol table header (this will normally be
755
  // the single SHT_SYMTAB section, but in principle it need not be).
756
  const unsigned int link = this->adjust_shndx(shdr.get_sh_link());
757
  typename This::Shdr symshdr(this, this->elf_file_.section_header(link));
758
 
759
  // Read the symbol table entry.
760
  unsigned int symndx = shdr.get_sh_info();
761
  if (symndx >= symshdr.get_sh_size() / This::sym_size)
762
    {
763
      this->error(_("section group %u info %u out of range"),
764
                  index, symndx);
765
      return false;
766
    }
767
  off_t symoff = symshdr.get_sh_offset() + symndx * This::sym_size;
768
  const unsigned char* psym = this->get_view(symoff, This::sym_size, true,
769
                                             false);
770
  elfcpp::Sym<size, big_endian> sym(psym);
771
 
772
  // Read the symbol table names.
773
  section_size_type symnamelen;
774
  const unsigned char* psymnamesu;
775
  psymnamesu = this->section_contents(this->adjust_shndx(symshdr.get_sh_link()),
776
                                      &symnamelen, true);
777
  const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
778
 
779
  // Get the section group signature.
780
  if (sym.get_st_name() >= symnamelen)
781
    {
782
      this->error(_("symbol %u name offset %u out of range"),
783
                  symndx, sym.get_st_name());
784
      return false;
785
    }
786
 
787
  std::string signature(psymnames + sym.get_st_name());
788
 
789
  // It seems that some versions of gas will create a section group
790
  // associated with a section symbol, and then fail to give a name to
791
  // the section symbol.  In such a case, use the name of the section.
792
  if (signature[0] == '\0' && sym.get_st_type() == elfcpp::STT_SECTION)
793
    {
794
      bool is_ordinary;
795
      unsigned int sym_shndx = this->adjust_sym_shndx(symndx,
796
                                                      sym.get_st_shndx(),
797
                                                      &is_ordinary);
798
      if (!is_ordinary || sym_shndx >= this->shnum())
799
        {
800
          this->error(_("symbol %u invalid section index %u"),
801
                      symndx, sym_shndx);
802
          return false;
803
        }
804
      typename This::Shdr member_shdr(shdrs + sym_shndx * This::shdr_size);
805
      if (member_shdr.get_sh_name() < section_names_size)
806
        signature = section_names + member_shdr.get_sh_name();
807
    }
808
 
809
  // Record this section group in the layout, and see whether we've already
810
  // seen one with the same signature.
811
  bool include_group;
812
  bool is_comdat;
813
  Kept_section* kept_section = NULL;
814
 
815
  if ((flags & elfcpp::GRP_COMDAT) == 0)
816
    {
817
      include_group = true;
818
      is_comdat = false;
819
    }
820
  else
821
    {
822
      include_group = layout->find_or_add_kept_section(signature,
823
                                                       this, index, true,
824
                                                       true, &kept_section);
825
      is_comdat = true;
826
    }
827
 
828
  if (is_comdat && include_group)
829
    {
830
      Incremental_inputs* incremental_inputs = layout->incremental_inputs();
831
      if (incremental_inputs != NULL)
832
        incremental_inputs->report_comdat_group(this, signature.c_str());
833
    }
834
 
835
  size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
836
 
837
  std::vector<unsigned int> shndxes;
838
  bool relocate_group = include_group && parameters->options().relocatable();
839
  if (relocate_group)
840
    shndxes.reserve(count - 1);
841
 
842
  for (size_t i = 1; i < count; ++i)
843
    {
844
      elfcpp::Elf_Word shndx =
845
        this->adjust_shndx(elfcpp::Swap<32, big_endian>::readval(pword + i));
846
 
847
      if (relocate_group)
848
        shndxes.push_back(shndx);
849
 
850
      if (shndx >= this->shnum())
851
        {
852
          this->error(_("section %u in section group %u out of range"),
853
                      shndx, index);
854
          continue;
855
        }
856
 
857
      // Check for an earlier section number, since we're going to get
858
      // it wrong--we may have already decided to include the section.
859
      if (shndx < index)
860
        this->error(_("invalid section group %u refers to earlier section %u"),
861
                    index, shndx);
862
 
863
      // Get the name of the member section.
864
      typename This::Shdr member_shdr(shdrs + shndx * This::shdr_size);
865
      if (member_shdr.get_sh_name() >= section_names_size)
866
        {
867
          // This is an error, but it will be diagnosed eventually
868
          // in do_layout, so we don't need to do anything here but
869
          // ignore it.
870
          continue;
871
        }
872
      std::string mname(section_names + member_shdr.get_sh_name());
873
 
874
      if (include_group)
875
        {
876
          if (is_comdat)
877
            kept_section->add_comdat_section(mname, shndx,
878
                                             member_shdr.get_sh_size());
879
        }
880
      else
881
        {
882
          (*omit)[shndx] = true;
883
 
884
          if (is_comdat)
885
            {
886
              Relobj* kept_object = kept_section->object();
887
              if (kept_section->is_comdat())
888
                {
889
                  // Find the corresponding kept section, and store
890
                  // that info in the discarded section table.
891
                  unsigned int kept_shndx;
892
                  uint64_t kept_size;
893
                  if (kept_section->find_comdat_section(mname, &kept_shndx,
894
                                                        &kept_size))
895
                    {
896
                      // We don't keep a mapping for this section if
897
                      // it has a different size.  The mapping is only
898
                      // used for relocation processing, and we don't
899
                      // want to treat the sections as similar if the
900
                      // sizes are different.  Checking the section
901
                      // size is the approach used by the GNU linker.
902
                      if (kept_size == member_shdr.get_sh_size())
903
                        this->set_kept_comdat_section(shndx, kept_object,
904
                                                      kept_shndx);
905
                    }
906
                }
907
              else
908
                {
909
                  // The existing section is a linkonce section.  Add
910
                  // a mapping if there is exactly one section in the
911
                  // group (which is true when COUNT == 2) and if it
912
                  // is the same size.
913
                  if (count == 2
914
                      && (kept_section->linkonce_size()
915
                          == member_shdr.get_sh_size()))
916
                    this->set_kept_comdat_section(shndx, kept_object,
917
                                                  kept_section->shndx());
918
                }
919
            }
920
        }
921
    }
922
 
923
  if (relocate_group)
924
    layout->layout_group(symtab, this, index, name, signature.c_str(),
925
                         shdr, flags, &shndxes);
926
 
927
  return include_group;
928
}
929
 
930
// Whether to include a linkonce section in the link.  NAME is the
931
// name of the section and SHDR is the section header.
932
 
933
// Linkonce sections are a GNU extension implemented in the original
934
// GNU linker before section groups were defined.  The semantics are
935
// that we only include one linkonce section with a given name.  The
936
// name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
937
// where T is the type of section and SYMNAME is the name of a symbol.
938
// In an attempt to make linkonce sections interact well with section
939
// groups, we try to identify SYMNAME and use it like a section group
940
// signature.  We want to block section groups with that signature,
941
// but not other linkonce sections with that signature.  We also use
942
// the full name of the linkonce section as a normal section group
943
// signature.
944
 
945
template<int size, bool big_endian>
946
bool
947
Sized_relobj_file<size, big_endian>::include_linkonce_section(
948
    Layout* layout,
949
    unsigned int index,
950
    const char* name,
951
    const elfcpp::Shdr<size, big_endian>& shdr)
952
{
953
  typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
954
  // In general the symbol name we want will be the string following
955
  // the last '.'.  However, we have to handle the case of
956
  // .gnu.linkonce.t.__i686.get_pc_thunk.bx, which was generated by
957
  // some versions of gcc.  So we use a heuristic: if the name starts
958
  // with ".gnu.linkonce.t.", we use everything after that.  Otherwise
959
  // we look for the last '.'.  We can't always simply skip
960
  // ".gnu.linkonce.X", because we have to deal with cases like
961
  // ".gnu.linkonce.d.rel.ro.local".
962
  const char* const linkonce_t = ".gnu.linkonce.t.";
963
  const char* symname;
964
  if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0)
965
    symname = name + strlen(linkonce_t);
966
  else
967
    symname = strrchr(name, '.') + 1;
968
  std::string sig1(symname);
969
  std::string sig2(name);
970
  Kept_section* kept1;
971
  Kept_section* kept2;
972
  bool include1 = layout->find_or_add_kept_section(sig1, this, index, false,
973
                                                   false, &kept1);
974
  bool include2 = layout->find_or_add_kept_section(sig2, this, index, false,
975
                                                   true, &kept2);
976
 
977
  if (!include2)
978
    {
979
      // We are not including this section because we already saw the
980
      // name of the section as a signature.  This normally implies
981
      // that the kept section is another linkonce section.  If it is
982
      // the same size, record it as the section which corresponds to
983
      // this one.
984
      if (kept2->object() != NULL
985
          && !kept2->is_comdat()
986
          && kept2->linkonce_size() == sh_size)
987
        this->set_kept_comdat_section(index, kept2->object(), kept2->shndx());
988
    }
989
  else if (!include1)
990
    {
991
      // The section is being discarded on the basis of its symbol
992
      // name.  This means that the corresponding kept section was
993
      // part of a comdat group, and it will be difficult to identify
994
      // the specific section within that group that corresponds to
995
      // this linkonce section.  We'll handle the simple case where
996
      // the group has only one member section.  Otherwise, it's not
997
      // worth the effort.
998
      unsigned int kept_shndx;
999
      uint64_t kept_size;
1000
      if (kept1->object() != NULL
1001
          && kept1->is_comdat()
1002
          && kept1->find_single_comdat_section(&kept_shndx, &kept_size)
1003
          && kept_size == sh_size)
1004
        this->set_kept_comdat_section(index, kept1->object(), kept_shndx);
1005
    }
1006
  else
1007
    {
1008
      kept1->set_linkonce_size(sh_size);
1009
      kept2->set_linkonce_size(sh_size);
1010
    }
1011
 
1012
  return include1 && include2;
1013
}
1014
 
1015
// Layout an input section.
1016
 
1017
template<int size, bool big_endian>
1018
inline void
1019
Sized_relobj_file<size, big_endian>::layout_section(Layout* layout,
1020
                                                    unsigned int shndx,
1021
                                                    const char* name,
1022
                                                    typename This::Shdr& shdr,
1023
                                                    unsigned int reloc_shndx,
1024
                                                    unsigned int reloc_type)
1025
{
1026
  off_t offset;
1027
  Output_section* os = layout->layout(this, shndx, name, shdr,
1028
                                          reloc_shndx, reloc_type, &offset);
1029
 
1030
  this->output_sections()[shndx] = os;
1031
  if (offset == -1)
1032
    this->section_offsets()[shndx] = invalid_address;
1033
  else
1034
    this->section_offsets()[shndx] = convert_types<Address, off_t>(offset);
1035
 
1036
  // If this section requires special handling, and if there are
1037
  // relocs that apply to it, then we must do the special handling
1038
  // before we apply the relocs.
1039
  if (offset == -1 && reloc_shndx != 0)
1040
    this->set_relocs_must_follow_section_writes();
1041
}
1042
 
1043
// Lay out the input sections.  We walk through the sections and check
1044
// whether they should be included in the link.  If they should, we
1045
// pass them to the Layout object, which will return an output section
1046
// and an offset.  
1047
// During garbage collection (--gc-sections) and identical code folding 
1048
// (--icf), this function is called twice.  When it is called the first 
1049
// time, it is for setting up some sections as roots to a work-list for
1050
// --gc-sections and to do comdat processing.  Actual layout happens the 
1051
// second time around after all the relevant sections have been determined.  
1052
// The first time, is_worklist_ready or is_icf_ready is false. It is then 
1053
// set to true after the garbage collection worklist or identical code 
1054
// folding is processed and the relevant sections to be kept are 
1055
// determined.  Then, this function is called again to layout the sections.
1056
 
1057
template<int size, bool big_endian>
1058
void
1059
Sized_relobj_file<size, big_endian>::do_layout(Symbol_table* symtab,
1060
                                               Layout* layout,
1061
                                               Read_symbols_data* sd)
1062
{
1063
  const unsigned int shnum = this->shnum();
1064
  bool is_gc_pass_one = ((parameters->options().gc_sections()
1065
                          && !symtab->gc()->is_worklist_ready())
1066
                         || (parameters->options().icf_enabled()
1067
                             && !symtab->icf()->is_icf_ready()));
1068
 
1069
  bool is_gc_pass_two = ((parameters->options().gc_sections()
1070
                          && symtab->gc()->is_worklist_ready())
1071
                         || (parameters->options().icf_enabled()
1072
                             && symtab->icf()->is_icf_ready()));
1073
 
1074
  bool is_gc_or_icf = (parameters->options().gc_sections()
1075
                       || parameters->options().icf_enabled());
1076
 
1077
  // Both is_gc_pass_one and is_gc_pass_two should not be true.
1078
  gold_assert(!(is_gc_pass_one  && is_gc_pass_two));
1079
 
1080
  if (shnum == 0)
1081
    return;
1082
  Symbols_data* gc_sd = NULL;
1083
  if (is_gc_pass_one)
1084
    {
1085
      // During garbage collection save the symbols data to use it when 
1086
      // re-entering this function.   
1087
      gc_sd = new Symbols_data;
1088
      this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum);
1089
      this->set_symbols_data(gc_sd);
1090
    }
1091
  else if (is_gc_pass_two)
1092
    {
1093
      gc_sd = this->get_symbols_data();
1094
    }
1095
 
1096
  const unsigned char* section_headers_data = NULL;
1097
  section_size_type section_names_size;
1098
  const unsigned char* symbols_data = NULL;
1099
  section_size_type symbols_size;
1100
  section_offset_type external_symbols_offset;
1101
  const unsigned char* symbol_names_data = NULL;
1102
  section_size_type symbol_names_size;
1103
 
1104
  if (is_gc_or_icf)
1105
    {
1106
      section_headers_data = gc_sd->section_headers_data;
1107
      section_names_size = gc_sd->section_names_size;
1108
      symbols_data = gc_sd->symbols_data;
1109
      symbols_size = gc_sd->symbols_size;
1110
      external_symbols_offset = gc_sd->external_symbols_offset;
1111
      symbol_names_data = gc_sd->symbol_names_data;
1112
      symbol_names_size = gc_sd->symbol_names_size;
1113
    }
1114
  else
1115
    {
1116
      section_headers_data = sd->section_headers->data();
1117
      section_names_size = sd->section_names_size;
1118
      if (sd->symbols != NULL)
1119
        symbols_data = sd->symbols->data();
1120
      symbols_size = sd->symbols_size;
1121
      external_symbols_offset = sd->external_symbols_offset;
1122
      if (sd->symbol_names != NULL)
1123
        symbol_names_data = sd->symbol_names->data();
1124
      symbol_names_size = sd->symbol_names_size;
1125
    }
1126
 
1127
  // Get the section headers.
1128
  const unsigned char* shdrs = section_headers_data;
1129
  const unsigned char* pshdrs;
1130
 
1131
  // Get the section names.
1132
  const unsigned char* pnamesu = (is_gc_or_icf)
1133
                                 ? gc_sd->section_names_data
1134
                                 : sd->section_names->data();
1135
 
1136
  const char* pnames = reinterpret_cast<const char*>(pnamesu);
1137
 
1138
  // If any input files have been claimed by plugins, we need to defer
1139
  // actual layout until the replacement files have arrived.
1140
  const bool should_defer_layout =
1141
      (parameters->options().has_plugins()
1142
       && parameters->options().plugins()->should_defer_layout());
1143
  unsigned int num_sections_to_defer = 0;
1144
 
1145
  // For each section, record the index of the reloc section if any.
1146
  // Use 0 to mean that there is no reloc section, -1U to mean that
1147
  // there is more than one.
1148
  std::vector<unsigned int> reloc_shndx(shnum, 0);
1149
  std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL);
1150
  // Skip the first, dummy, section.
1151
  pshdrs = shdrs + This::shdr_size;
1152
  for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1153
    {
1154
      typename This::Shdr shdr(pshdrs);
1155
 
1156
      // Count the number of sections whose layout will be deferred.
1157
      if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1158
        ++num_sections_to_defer;
1159
 
1160
      unsigned int sh_type = shdr.get_sh_type();
1161
      if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA)
1162
        {
1163
          unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info());
1164
          if (target_shndx == 0 || target_shndx >= shnum)
1165
            {
1166
              this->error(_("relocation section %u has bad info %u"),
1167
                          i, target_shndx);
1168
              continue;
1169
            }
1170
 
1171
          if (reloc_shndx[target_shndx] != 0)
1172
            reloc_shndx[target_shndx] = -1U;
1173
          else
1174
            {
1175
              reloc_shndx[target_shndx] = i;
1176
              reloc_type[target_shndx] = sh_type;
1177
            }
1178
        }
1179
    }
1180
 
1181
  Output_sections& out_sections(this->output_sections());
1182
  std::vector<Address>& out_section_offsets(this->section_offsets());
1183
 
1184
  if (!is_gc_pass_two)
1185
    {
1186
      out_sections.resize(shnum);
1187
      out_section_offsets.resize(shnum);
1188
    }
1189
 
1190
  // If we are only linking for symbols, then there is nothing else to
1191
  // do here.
1192
  if (this->input_file()->just_symbols())
1193
    {
1194
      if (!is_gc_pass_two)
1195
        {
1196
          delete sd->section_headers;
1197
          sd->section_headers = NULL;
1198
          delete sd->section_names;
1199
          sd->section_names = NULL;
1200
        }
1201
      return;
1202
    }
1203
 
1204
  if (num_sections_to_defer > 0)
1205
    {
1206
      parameters->options().plugins()->add_deferred_layout_object(this);
1207
      this->deferred_layout_.reserve(num_sections_to_defer);
1208
    }
1209
 
1210
  // Whether we've seen a .note.GNU-stack section.
1211
  bool seen_gnu_stack = false;
1212
  // The flags of a .note.GNU-stack section.
1213
  uint64_t gnu_stack_flags = 0;
1214
 
1215
  // Keep track of which sections to omit.
1216
  std::vector<bool> omit(shnum, false);
1217
 
1218
  // Keep track of reloc sections when emitting relocations.
1219
  const bool relocatable = parameters->options().relocatable();
1220
  const bool emit_relocs = (relocatable
1221
                            || parameters->options().emit_relocs());
1222
  std::vector<unsigned int> reloc_sections;
1223
 
1224
  // Keep track of .eh_frame sections.
1225
  std::vector<unsigned int> eh_frame_sections;
1226
 
1227
  // Skip the first, dummy, section.
1228
  pshdrs = shdrs + This::shdr_size;
1229
  for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size)
1230
    {
1231
      typename This::Shdr shdr(pshdrs);
1232
 
1233
      if (shdr.get_sh_name() >= section_names_size)
1234
        {
1235
          this->error(_("bad section name offset for section %u: %lu"),
1236
                      i, static_cast<unsigned long>(shdr.get_sh_name()));
1237
          return;
1238
        }
1239
 
1240
      const char* name = pnames + shdr.get_sh_name();
1241
 
1242
      if (!is_gc_pass_two)
1243
        {
1244
          if (this->handle_gnu_warning_section(name, i, symtab))
1245
            {
1246
              if (!relocatable)
1247
                omit[i] = true;
1248
            }
1249
 
1250
          // The .note.GNU-stack section is special.  It gives the
1251
          // protection flags that this object file requires for the stack
1252
          // in memory.
1253
          if (strcmp(name, ".note.GNU-stack") == 0)
1254
            {
1255
              seen_gnu_stack = true;
1256
              gnu_stack_flags |= shdr.get_sh_flags();
1257
              omit[i] = true;
1258
            }
1259
 
1260
          // The .note.GNU-split-stack section is also special.  It
1261
          // indicates that the object was compiled with
1262
          // -fsplit-stack.
1263
          if (this->handle_split_stack_section(name))
1264
            {
1265
              if (!parameters->options().relocatable()
1266
                  && !parameters->options().shared())
1267
                omit[i] = true;
1268
            }
1269
 
1270
          // Skip attributes section.
1271
          if (parameters->target().is_attributes_section(name))
1272
            {
1273
              omit[i] = true;
1274
            }
1275
 
1276
          bool discard = omit[i];
1277
          if (!discard)
1278
            {
1279
              if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
1280
                {
1281
                  if (!this->include_section_group(symtab, layout, i, name,
1282
                                                   shdrs, pnames,
1283
                                                   section_names_size,
1284
                                                   &omit))
1285
                    discard = true;
1286
                }
1287
              else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0
1288
                       && Layout::is_linkonce(name))
1289
                {
1290
                  if (!this->include_linkonce_section(layout, i, name, shdr))
1291
                    discard = true;
1292
                }
1293
            }
1294
 
1295
          // Add the section to the incremental inputs layout.
1296
          Incremental_inputs* incremental_inputs = layout->incremental_inputs();
1297
          if (incremental_inputs != NULL
1298
              && !discard
1299
              && (shdr.get_sh_type() == elfcpp::SHT_PROGBITS
1300
                  || shdr.get_sh_type() == elfcpp::SHT_NOBITS
1301
                  || shdr.get_sh_type() == elfcpp::SHT_NOTE))
1302
            incremental_inputs->report_input_section(this, i, name,
1303
                                                     shdr.get_sh_size());
1304
 
1305
          if (discard)
1306
            {
1307
              // Do not include this section in the link.
1308
              out_sections[i] = NULL;
1309
              out_section_offsets[i] = invalid_address;
1310
              continue;
1311
            }
1312
        }
1313
 
1314
      if (is_gc_pass_one && parameters->options().gc_sections())
1315
        {
1316
          if (this->is_section_name_included(name)
1317
              || shdr.get_sh_type() == elfcpp::SHT_INIT_ARRAY
1318
              || shdr.get_sh_type() == elfcpp::SHT_FINI_ARRAY)
1319
            {
1320
              symtab->gc()->worklist().push(Section_id(this, i));
1321
            }
1322
          // If the section name XXX can be represented as a C identifier
1323
          // it cannot be discarded if there are references to
1324
          // __start_XXX and __stop_XXX symbols.  These need to be
1325
          // specially handled.
1326
          if (is_cident(name))
1327
            {
1328
              symtab->gc()->add_cident_section(name, Section_id(this, i));
1329
            }
1330
        }
1331
 
1332
      // When doing a relocatable link we are going to copy input
1333
      // reloc sections into the output.  We only want to copy the
1334
      // ones associated with sections which are not being discarded.
1335
      // However, we don't know that yet for all sections.  So save
1336
      // reloc sections and process them later. Garbage collection is
1337
      // not triggered when relocatable code is desired.
1338
      if (emit_relocs
1339
          && (shdr.get_sh_type() == elfcpp::SHT_REL
1340
              || shdr.get_sh_type() == elfcpp::SHT_RELA))
1341
        {
1342
          reloc_sections.push_back(i);
1343
          continue;
1344
        }
1345
 
1346
      if (relocatable && shdr.get_sh_type() == elfcpp::SHT_GROUP)
1347
        continue;
1348
 
1349
      // The .eh_frame section is special.  It holds exception frame
1350
      // information that we need to read in order to generate the
1351
      // exception frame header.  We process these after all the other
1352
      // sections so that the exception frame reader can reliably
1353
      // determine which sections are being discarded, and discard the
1354
      // corresponding information.
1355
      if (!relocatable
1356
          && strcmp(name, ".eh_frame") == 0
1357
          && this->check_eh_frame_flags(&shdr))
1358
        {
1359
          if (is_gc_pass_one)
1360
            {
1361
              out_sections[i] = reinterpret_cast<Output_section*>(1);
1362
              out_section_offsets[i] = invalid_address;
1363
            }
1364
          else
1365
            eh_frame_sections.push_back(i);
1366
          continue;
1367
        }
1368
 
1369
      if (is_gc_pass_two && parameters->options().gc_sections())
1370
        {
1371
          // This is executed during the second pass of garbage 
1372
          // collection. do_layout has been called before and some 
1373
          // sections have been already discarded. Simply ignore 
1374
          // such sections this time around.
1375
          if (out_sections[i] == NULL)
1376
            {
1377
              gold_assert(out_section_offsets[i] == invalid_address);
1378
              continue;
1379
            }
1380
          if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1381
              && symtab->gc()->is_section_garbage(this, i))
1382
              {
1383
                if (parameters->options().print_gc_sections())
1384
                  gold_info(_("%s: removing unused section from '%s'"
1385
                              " in file '%s'"),
1386
                            program_name, this->section_name(i).c_str(),
1387
                            this->name().c_str());
1388
                out_sections[i] = NULL;
1389
                out_section_offsets[i] = invalid_address;
1390
                continue;
1391
              }
1392
        }
1393
 
1394
      if (is_gc_pass_two && parameters->options().icf_enabled())
1395
        {
1396
          if (out_sections[i] == NULL)
1397
            {
1398
              gold_assert(out_section_offsets[i] == invalid_address);
1399
              continue;
1400
            }
1401
          if (((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0)
1402
              && symtab->icf()->is_section_folded(this, i))
1403
              {
1404
                if (parameters->options().print_icf_sections())
1405
                  {
1406
                    Section_id folded =
1407
                                symtab->icf()->get_folded_section(this, i);
1408
                    Relobj* folded_obj =
1409
                                reinterpret_cast<Relobj*>(folded.first);
1410
                    gold_info(_("%s: ICF folding section '%s' in file '%s'"
1411
                                "into '%s' in file '%s'"),
1412
                              program_name, this->section_name(i).c_str(),
1413
                              this->name().c_str(),
1414
                              folded_obj->section_name(folded.second).c_str(),
1415
                              folded_obj->name().c_str());
1416
                  }
1417
                out_sections[i] = NULL;
1418
                out_section_offsets[i] = invalid_address;
1419
                continue;
1420
              }
1421
        }
1422
 
1423
      // Defer layout here if input files are claimed by plugins.  When gc
1424
      // is turned on this function is called twice.  For the second call
1425
      // should_defer_layout should be false.
1426
      if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
1427
        {
1428
          gold_assert(!is_gc_pass_two);
1429
          this->deferred_layout_.push_back(Deferred_layout(i, name,
1430
                                                           pshdrs,
1431
                                                           reloc_shndx[i],
1432
                                                           reloc_type[i]));
1433
          // Put dummy values here; real values will be supplied by
1434
          // do_layout_deferred_sections.
1435
          out_sections[i] = reinterpret_cast<Output_section*>(2);
1436
          out_section_offsets[i] = invalid_address;
1437
          continue;
1438
        }
1439
 
1440
      // During gc_pass_two if a section that was previously deferred is
1441
      // found, do not layout the section as layout_deferred_sections will
1442
      // do it later from gold.cc.
1443
      if (is_gc_pass_two
1444
          && (out_sections[i] == reinterpret_cast<Output_section*>(2)))
1445
        continue;
1446
 
1447
      if (is_gc_pass_one)
1448
        {
1449
          // This is during garbage collection. The out_sections are 
1450
          // assigned in the second call to this function. 
1451
          out_sections[i] = reinterpret_cast<Output_section*>(1);
1452
          out_section_offsets[i] = invalid_address;
1453
        }
1454
      else
1455
        {
1456
          // When garbage collection is switched on the actual layout
1457
          // only happens in the second call.
1458
          this->layout_section(layout, i, name, shdr, reloc_shndx[i],
1459
                               reloc_type[i]);
1460
        }
1461
    }
1462
 
1463
  if (!is_gc_pass_two)
1464
    layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags, this);
1465
 
1466
  // When doing a relocatable link handle the reloc sections at the
1467
  // end.  Garbage collection  and Identical Code Folding is not 
1468
  // turned on for relocatable code. 
1469
  if (emit_relocs)
1470
    this->size_relocatable_relocs();
1471
 
1472
  gold_assert(!(is_gc_or_icf) || reloc_sections.empty());
1473
 
1474
  for (std::vector<unsigned int>::const_iterator p = reloc_sections.begin();
1475
       p != reloc_sections.end();
1476
       ++p)
1477
    {
1478
      unsigned int i = *p;
1479
      const unsigned char* pshdr;
1480
      pshdr = section_headers_data + i * This::shdr_size;
1481
      typename This::Shdr shdr(pshdr);
1482
 
1483
      unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
1484
      if (data_shndx >= shnum)
1485
        {
1486
          // We already warned about this above.
1487
          continue;
1488
        }
1489
 
1490
      Output_section* data_section = out_sections[data_shndx];
1491
      if (data_section == reinterpret_cast<Output_section*>(2))
1492
        {
1493
          // The layout for the data section was deferred, so we need
1494
          // to defer the relocation section, too.
1495
          const char* name = pnames + shdr.get_sh_name();
1496
          this->deferred_layout_relocs_.push_back(
1497
              Deferred_layout(i, name, pshdr, 0, elfcpp::SHT_NULL));
1498
          out_sections[i] = reinterpret_cast<Output_section*>(2);
1499
          out_section_offsets[i] = invalid_address;
1500
          continue;
1501
        }
1502
      if (data_section == NULL)
1503
        {
1504
          out_sections[i] = NULL;
1505
          out_section_offsets[i] = invalid_address;
1506
          continue;
1507
        }
1508
 
1509
      Relocatable_relocs* rr = new Relocatable_relocs();
1510
      this->set_relocatable_relocs(i, rr);
1511
 
1512
      Output_section* os = layout->layout_reloc(this, i, shdr, data_section,
1513
                                                rr);
1514
      out_sections[i] = os;
1515
      out_section_offsets[i] = invalid_address;
1516
    }
1517
 
1518
  // Handle the .eh_frame sections at the end.
1519
  gold_assert(!is_gc_pass_one || eh_frame_sections.empty());
1520
  for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
1521
       p != eh_frame_sections.end();
1522
       ++p)
1523
    {
1524
      gold_assert(this->has_eh_frame_);
1525
      gold_assert(external_symbols_offset != 0);
1526
 
1527
      unsigned int i = *p;
1528
      const unsigned char* pshdr;
1529
      pshdr = section_headers_data + i * This::shdr_size;
1530
      typename This::Shdr shdr(pshdr);
1531
 
1532
      off_t offset;
1533
      Output_section* os = layout->layout_eh_frame(this,
1534
                                                   symbols_data,
1535
                                                   symbols_size,
1536
                                                   symbol_names_data,
1537
                                                   symbol_names_size,
1538
                                                   i, shdr,
1539
                                                   reloc_shndx[i],
1540
                                                   reloc_type[i],
1541
                                                   &offset);
1542
      out_sections[i] = os;
1543
      if (os == NULL || offset == -1)
1544
        {
1545
          // An object can contain at most one section holding exception
1546
          // frame information.
1547
          gold_assert(this->discarded_eh_frame_shndx_ == -1U);
1548
          this->discarded_eh_frame_shndx_ = i;
1549
          out_section_offsets[i] = invalid_address;
1550
        }
1551
      else
1552
        out_section_offsets[i] = convert_types<Address, off_t>(offset);
1553
 
1554
      // If this section requires special handling, and if there are
1555
      // relocs that apply to it, then we must do the special handling
1556
      // before we apply the relocs.
1557
      if (os != NULL && offset == -1 && reloc_shndx[i] != 0)
1558
        this->set_relocs_must_follow_section_writes();
1559
    }
1560
 
1561
  if (is_gc_pass_two)
1562
    {
1563
      delete[] gc_sd->section_headers_data;
1564
      delete[] gc_sd->section_names_data;
1565
      delete[] gc_sd->symbols_data;
1566
      delete[] gc_sd->symbol_names_data;
1567
      this->set_symbols_data(NULL);
1568
    }
1569
  else
1570
    {
1571
      delete sd->section_headers;
1572
      sd->section_headers = NULL;
1573
      delete sd->section_names;
1574
      sd->section_names = NULL;
1575
    }
1576
}
1577
 
1578
// Layout sections whose layout was deferred while waiting for
1579
// input files from a plugin.
1580
 
1581
template<int size, bool big_endian>
1582
void
1583
Sized_relobj_file<size, big_endian>::do_layout_deferred_sections(Layout* layout)
1584
{
1585
  typename std::vector<Deferred_layout>::iterator deferred;
1586
 
1587
  for (deferred = this->deferred_layout_.begin();
1588
       deferred != this->deferred_layout_.end();
1589
       ++deferred)
1590
    {
1591
      typename This::Shdr shdr(deferred->shdr_data_);
1592
      // If the section is not included, it is because the garbage collector
1593
      // decided it is not needed.  Avoid reverting that decision.
1594
      if (!this->is_section_included(deferred->shndx_))
1595
        continue;
1596
 
1597
      this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(),
1598
                           shdr, deferred->reloc_shndx_, deferred->reloc_type_);
1599
    }
1600
 
1601
  this->deferred_layout_.clear();
1602
 
1603
  // Now handle the deferred relocation sections.
1604
 
1605
  Output_sections& out_sections(this->output_sections());
1606
  std::vector<Address>& out_section_offsets(this->section_offsets());
1607
 
1608
  for (deferred = this->deferred_layout_relocs_.begin();
1609
       deferred != this->deferred_layout_relocs_.end();
1610
       ++deferred)
1611
    {
1612
      unsigned int shndx = deferred->shndx_;
1613
      typename This::Shdr shdr(deferred->shdr_data_);
1614
      unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info());
1615
 
1616
      Output_section* data_section = out_sections[data_shndx];
1617
      if (data_section == NULL)
1618
        {
1619
          out_sections[shndx] = NULL;
1620
          out_section_offsets[shndx] = invalid_address;
1621
          continue;
1622
        }
1623
 
1624
      Relocatable_relocs* rr = new Relocatable_relocs();
1625
      this->set_relocatable_relocs(shndx, rr);
1626
 
1627
      Output_section* os = layout->layout_reloc(this, shndx, shdr,
1628
                                                data_section, rr);
1629
      out_sections[shndx] = os;
1630
      out_section_offsets[shndx] = invalid_address;
1631
    }
1632
}
1633
 
1634
// Add the symbols to the symbol table.
1635
 
1636
template<int size, bool big_endian>
1637
void
1638
Sized_relobj_file<size, big_endian>::do_add_symbols(Symbol_table* symtab,
1639
                                                    Read_symbols_data* sd,
1640
                                                    Layout*)
1641
{
1642
  if (sd->symbols == NULL)
1643
    {
1644
      gold_assert(sd->symbol_names == NULL);
1645
      return;
1646
    }
1647
 
1648
  const int sym_size = This::sym_size;
1649
  size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1650
                     / sym_size);
1651
  if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset)
1652
    {
1653
      this->error(_("size of symbols is not multiple of symbol size"));
1654
      return;
1655
    }
1656
 
1657
  this->symbols_.resize(symcount);
1658
 
1659
  const char* sym_names =
1660
    reinterpret_cast<const char*>(sd->symbol_names->data());
1661
  symtab->add_from_relobj(this,
1662
                          sd->symbols->data() + sd->external_symbols_offset,
1663
                          symcount, this->local_symbol_count_,
1664
                          sym_names, sd->symbol_names_size,
1665
                          &this->symbols_,
1666
                          &this->defined_count_);
1667
 
1668
  delete sd->symbols;
1669
  sd->symbols = NULL;
1670
  delete sd->symbol_names;
1671
  sd->symbol_names = NULL;
1672
}
1673
 
1674
// Find out if this object, that is a member of a lib group, should be included
1675
// in the link. We check every symbol defined by this object. If the symbol
1676
// table has a strong undefined reference to that symbol, we have to include
1677
// the object.
1678
 
1679
template<int size, bool big_endian>
1680
Archive::Should_include
1681
Sized_relobj_file<size, big_endian>::do_should_include_member(
1682
    Symbol_table* symtab,
1683
    Layout* layout,
1684
    Read_symbols_data* sd,
1685
    std::string* why)
1686
{
1687
  char* tmpbuf = NULL;
1688
  size_t tmpbuflen = 0;
1689
  const char* sym_names =
1690
      reinterpret_cast<const char*>(sd->symbol_names->data());
1691
  const unsigned char* syms =
1692
      sd->symbols->data() + sd->external_symbols_offset;
1693
  const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1694
  size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1695
                         / sym_size);
1696
 
1697
  const unsigned char* p = syms;
1698
 
1699
  for (size_t i = 0; i < symcount; ++i, p += sym_size)
1700
    {
1701
      elfcpp::Sym<size, big_endian> sym(p);
1702
      unsigned int st_shndx = sym.get_st_shndx();
1703
      if (st_shndx == elfcpp::SHN_UNDEF)
1704
        continue;
1705
 
1706
      unsigned int st_name = sym.get_st_name();
1707
      const char* name = sym_names + st_name;
1708
      Symbol* symbol;
1709
      Archive::Should_include t = Archive::should_include_member(symtab,
1710
                                                                 layout,
1711
                                                                 name,
1712
                                                                 &symbol, why,
1713
                                                                 &tmpbuf,
1714
                                                                 &tmpbuflen);
1715
      if (t == Archive::SHOULD_INCLUDE_YES)
1716
        {
1717
          if (tmpbuf != NULL)
1718
            free(tmpbuf);
1719
          return t;
1720
        }
1721
    }
1722
  if (tmpbuf != NULL)
1723
    free(tmpbuf);
1724
  return Archive::SHOULD_INCLUDE_UNKNOWN;
1725
}
1726
 
1727
// Iterate over global defined symbols, calling a visitor class V for each.
1728
 
1729
template<int size, bool big_endian>
1730
void
1731
Sized_relobj_file<size, big_endian>::do_for_all_global_symbols(
1732
    Read_symbols_data* sd,
1733
    Library_base::Symbol_visitor_base* v)
1734
{
1735
  const char* sym_names =
1736
      reinterpret_cast<const char*>(sd->symbol_names->data());
1737
  const unsigned char* syms =
1738
      sd->symbols->data() + sd->external_symbols_offset;
1739
  const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1740
  size_t symcount = ((sd->symbols_size - sd->external_symbols_offset)
1741
                     / sym_size);
1742
  const unsigned char* p = syms;
1743
 
1744
  for (size_t i = 0; i < symcount; ++i, p += sym_size)
1745
    {
1746
      elfcpp::Sym<size, big_endian> sym(p);
1747
      if (sym.get_st_shndx() != elfcpp::SHN_UNDEF)
1748
        v->visit(sym_names + sym.get_st_name());
1749
    }
1750
}
1751
 
1752
// Return whether the local symbol SYMNDX has a PLT offset.
1753
 
1754
template<int size, bool big_endian>
1755
bool
1756
Sized_relobj_file<size, big_endian>::local_has_plt_offset(
1757
    unsigned int symndx) const
1758
{
1759
  typename Local_plt_offsets::const_iterator p =
1760
    this->local_plt_offsets_.find(symndx);
1761
  return p != this->local_plt_offsets_.end();
1762
}
1763
 
1764
// Get the PLT offset of a local symbol.
1765
 
1766
template<int size, bool big_endian>
1767
unsigned int
1768
Sized_relobj_file<size, big_endian>::local_plt_offset(unsigned int symndx) const
1769
{
1770
  typename Local_plt_offsets::const_iterator p =
1771
    this->local_plt_offsets_.find(symndx);
1772
  gold_assert(p != this->local_plt_offsets_.end());
1773
  return p->second;
1774
}
1775
 
1776
// Set the PLT offset of a local symbol.
1777
 
1778
template<int size, bool big_endian>
1779
void
1780
Sized_relobj_file<size, big_endian>::set_local_plt_offset(
1781
    unsigned int symndx, unsigned int plt_offset)
1782
{
1783
  std::pair<typename Local_plt_offsets::iterator, bool> ins =
1784
    this->local_plt_offsets_.insert(std::make_pair(symndx, plt_offset));
1785
  gold_assert(ins.second);
1786
}
1787
 
1788
// First pass over the local symbols.  Here we add their names to
1789
// *POOL and *DYNPOOL, and we store the symbol value in
1790
// THIS->LOCAL_VALUES_.  This function is always called from a
1791
// singleton thread.  This is followed by a call to
1792
// finalize_local_symbols.
1793
 
1794
template<int size, bool big_endian>
1795
void
1796
Sized_relobj_file<size, big_endian>::do_count_local_symbols(Stringpool* pool,
1797
                                                            Stringpool* dynpool)
1798
{
1799
  gold_assert(this->symtab_shndx_ != -1U);
1800
  if (this->symtab_shndx_ == 0)
1801
    {
1802
      // This object has no symbols.  Weird but legal.
1803
      return;
1804
    }
1805
 
1806
  // Read the symbol table section header.
1807
  const unsigned int symtab_shndx = this->symtab_shndx_;
1808
  typename This::Shdr symtabshdr(this,
1809
                                 this->elf_file_.section_header(symtab_shndx));
1810
  gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
1811
 
1812
  // Read the local symbols.
1813
  const int sym_size = This::sym_size;
1814
  const unsigned int loccount = this->local_symbol_count_;
1815
  gold_assert(loccount == symtabshdr.get_sh_info());
1816
  off_t locsize = loccount * sym_size;
1817
  const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
1818
                                              locsize, true, true);
1819
 
1820
  // Read the symbol names.
1821
  const unsigned int strtab_shndx =
1822
    this->adjust_shndx(symtabshdr.get_sh_link());
1823
  section_size_type strtab_size;
1824
  const unsigned char* pnamesu = this->section_contents(strtab_shndx,
1825
                                                        &strtab_size,
1826
                                                        true);
1827
  const char* pnames = reinterpret_cast<const char*>(pnamesu);
1828
 
1829
  // Loop over the local symbols.
1830
 
1831
  const Output_sections& out_sections(this->output_sections());
1832
  unsigned int shnum = this->shnum();
1833
  unsigned int count = 0;
1834
  unsigned int dyncount = 0;
1835
  // Skip the first, dummy, symbol.
1836
  psyms += sym_size;
1837
  bool strip_all = parameters->options().strip_all();
1838
  bool discard_all = parameters->options().discard_all();
1839
  bool discard_locals = parameters->options().discard_locals();
1840
  for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
1841
    {
1842
      elfcpp::Sym<size, big_endian> sym(psyms);
1843
 
1844
      Symbol_value<size>& lv(this->local_values_[i]);
1845
 
1846
      bool is_ordinary;
1847
      unsigned int shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
1848
                                                  &is_ordinary);
1849
      lv.set_input_shndx(shndx, is_ordinary);
1850
 
1851
      if (sym.get_st_type() == elfcpp::STT_SECTION)
1852
        lv.set_is_section_symbol();
1853
      else if (sym.get_st_type() == elfcpp::STT_TLS)
1854
        lv.set_is_tls_symbol();
1855
      else if (sym.get_st_type() == elfcpp::STT_GNU_IFUNC)
1856
        lv.set_is_ifunc_symbol();
1857
 
1858
      // Save the input symbol value for use in do_finalize_local_symbols().
1859
      lv.set_input_value(sym.get_st_value());
1860
 
1861
      // Decide whether this symbol should go into the output file.
1862
 
1863
      if ((shndx < shnum && out_sections[shndx] == NULL)
1864
          || shndx == this->discarded_eh_frame_shndx_)
1865
        {
1866
          lv.set_no_output_symtab_entry();
1867
          gold_assert(!lv.needs_output_dynsym_entry());
1868
          continue;
1869
        }
1870
 
1871
      if (sym.get_st_type() == elfcpp::STT_SECTION)
1872
        {
1873
          lv.set_no_output_symtab_entry();
1874
          gold_assert(!lv.needs_output_dynsym_entry());
1875
          continue;
1876
        }
1877
 
1878
      if (sym.get_st_name() >= strtab_size)
1879
        {
1880
          this->error(_("local symbol %u section name out of range: %u >= %u"),
1881
                      i, sym.get_st_name(),
1882
                      static_cast<unsigned int>(strtab_size));
1883
          lv.set_no_output_symtab_entry();
1884
          continue;
1885
        }
1886
 
1887
      const char* name = pnames + sym.get_st_name();
1888
 
1889
      // If needed, add the symbol to the dynamic symbol table string pool.
1890
      if (lv.needs_output_dynsym_entry())
1891
        {
1892
          dynpool->add(name, true, NULL);
1893
          ++dyncount;
1894
        }
1895
 
1896
      if (strip_all
1897
          || (discard_all && lv.may_be_discarded_from_output_symtab()))
1898
        {
1899
          lv.set_no_output_symtab_entry();
1900
          continue;
1901
        }
1902
 
1903
      // If --discard-locals option is used, discard all temporary local
1904
      // symbols.  These symbols start with system-specific local label
1905
      // prefixes, typically .L for ELF system.  We want to be compatible
1906
      // with GNU ld so here we essentially use the same check in
1907
      // bfd_is_local_label().  The code is different because we already
1908
      // know that:
1909
      //
1910
      //   - the symbol is local and thus cannot have global or weak binding.
1911
      //   - the symbol is not a section symbol.
1912
      //   - the symbol has a name.
1913
      //
1914
      // We do not discard a symbol if it needs a dynamic symbol entry.
1915
      if (discard_locals
1916
          && sym.get_st_type() != elfcpp::STT_FILE
1917
          && !lv.needs_output_dynsym_entry()
1918
          && lv.may_be_discarded_from_output_symtab()
1919
          && parameters->target().is_local_label_name(name))
1920
        {
1921
          lv.set_no_output_symtab_entry();
1922
          continue;
1923
        }
1924
 
1925
      // Discard the local symbol if -retain_symbols_file is specified
1926
      // and the local symbol is not in that file.
1927
      if (!parameters->options().should_retain_symbol(name))
1928
        {
1929
          lv.set_no_output_symtab_entry();
1930
          continue;
1931
        }
1932
 
1933
      // Add the symbol to the symbol table string pool.
1934
      pool->add(name, true, NULL);
1935
      ++count;
1936
    }
1937
 
1938
  this->output_local_symbol_count_ = count;
1939
  this->output_local_dynsym_count_ = dyncount;
1940
}
1941
 
1942
// Compute the final value of a local symbol.
1943
 
1944
template<int size, bool big_endian>
1945
typename Sized_relobj_file<size, big_endian>::Compute_final_local_value_status
1946
Sized_relobj_file<size, big_endian>::compute_final_local_value_internal(
1947
    unsigned int r_sym,
1948
    const Symbol_value<size>* lv_in,
1949
    Symbol_value<size>* lv_out,
1950
    bool relocatable,
1951
    const Output_sections& out_sections,
1952
    const std::vector<Address>& out_offsets,
1953
    const Symbol_table* symtab)
1954
{
1955
  // We are going to overwrite *LV_OUT, if it has a merged symbol value,
1956
  // we may have a memory leak.
1957
  gold_assert(lv_out->has_output_value());
1958
 
1959
  bool is_ordinary;
1960
  unsigned int shndx = lv_in->input_shndx(&is_ordinary);
1961
 
1962
  // Set the output symbol value.
1963
 
1964
  if (!is_ordinary)
1965
    {
1966
      if (shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(shndx))
1967
        lv_out->set_output_value(lv_in->input_value());
1968
      else
1969
        {
1970
          this->error(_("unknown section index %u for local symbol %u"),
1971
                      shndx, r_sym);
1972
          lv_out->set_output_value(0);
1973
          return This::CFLV_ERROR;
1974
        }
1975
    }
1976
  else
1977
    {
1978
      if (shndx >= this->shnum())
1979
        {
1980
          this->error(_("local symbol %u section index %u out of range"),
1981
                      r_sym, shndx);
1982
          lv_out->set_output_value(0);
1983
          return This::CFLV_ERROR;
1984
        }
1985
 
1986
      Output_section* os = out_sections[shndx];
1987
      Address secoffset = out_offsets[shndx];
1988
      if (symtab->is_section_folded(this, shndx))
1989
        {
1990
          gold_assert(os == NULL && secoffset == invalid_address);
1991
          // Get the os of the section it is folded onto.
1992
          Section_id folded = symtab->icf()->get_folded_section(this,
1993
                                                                shndx);
1994
          gold_assert(folded.first != NULL);
1995
          Sized_relobj_file<size, big_endian>* folded_obj = reinterpret_cast
1996
            <Sized_relobj_file<size, big_endian>*>(folded.first);
1997
          os = folded_obj->output_section(folded.second);
1998
          gold_assert(os != NULL);
1999
          secoffset = folded_obj->get_output_section_offset(folded.second);
2000
 
2001
          // This could be a relaxed input section.
2002
          if (secoffset == invalid_address)
2003
            {
2004
              const Output_relaxed_input_section* relaxed_section =
2005
                os->find_relaxed_input_section(folded_obj, folded.second);
2006
              gold_assert(relaxed_section != NULL);
2007
              secoffset = relaxed_section->address() - os->address();
2008
            }
2009
        }
2010
 
2011
      if (os == NULL)
2012
        {
2013
          // This local symbol belongs to a section we are discarding.
2014
          // In some cases when applying relocations later, we will
2015
          // attempt to match it to the corresponding kept section,
2016
          // so we leave the input value unchanged here.
2017
          return This::CFLV_DISCARDED;
2018
        }
2019
      else if (secoffset == invalid_address)
2020
        {
2021
          uint64_t start;
2022
 
2023
          // This is a SHF_MERGE section or one which otherwise
2024
          // requires special handling.
2025
          if (shndx == this->discarded_eh_frame_shndx_)
2026
            {
2027
              // This local symbol belongs to a discarded .eh_frame
2028
              // section.  Just treat it like the case in which
2029
              // os == NULL above.
2030
              gold_assert(this->has_eh_frame_);
2031
              return This::CFLV_DISCARDED;
2032
            }
2033
          else if (!lv_in->is_section_symbol())
2034
            {
2035
              // This is not a section symbol.  We can determine
2036
              // the final value now.
2037
              lv_out->set_output_value(
2038
                  os->output_address(this, shndx, lv_in->input_value()));
2039
            }
2040
          else if (!os->find_starting_output_address(this, shndx, &start))
2041
            {
2042
              // This is a section symbol, but apparently not one in a
2043
              // merged section.  First check to see if this is a relaxed
2044
              // input section.  If so, use its address.  Otherwise just
2045
              // use the start of the output section.  This happens with
2046
              // relocatable links when the input object has section
2047
              // symbols for arbitrary non-merge sections.
2048
              const Output_section_data* posd =
2049
                os->find_relaxed_input_section(this, shndx);
2050
              if (posd != NULL)
2051
                {
2052
                  Address relocatable_link_adjustment =
2053
                    relocatable ? os->address() : 0;
2054
                  lv_out->set_output_value(posd->address()
2055
                                           - relocatable_link_adjustment);
2056
                }
2057
              else
2058
                lv_out->set_output_value(os->address());
2059
            }
2060
          else
2061
            {
2062
              // We have to consider the addend to determine the
2063
              // value to use in a relocation.  START is the start
2064
              // of this input section.  If we are doing a relocatable
2065
              // link, use offset from start output section instead of
2066
              // address.
2067
              Address adjusted_start =
2068
                relocatable ? start - os->address() : start;
2069
              Merged_symbol_value<size>* msv =
2070
                new Merged_symbol_value<size>(lv_in->input_value(),
2071
                                              adjusted_start);
2072
              lv_out->set_merged_symbol_value(msv);
2073
            }
2074
        }
2075
      else if (lv_in->is_tls_symbol())
2076
        lv_out->set_output_value(os->tls_offset()
2077
                                 + secoffset
2078
                                 + lv_in->input_value());
2079
      else
2080
        lv_out->set_output_value((relocatable ? 0 : os->address())
2081
                                 + secoffset
2082
                                 + lv_in->input_value());
2083
    }
2084
  return This::CFLV_OK;
2085
}
2086
 
2087
// Compute final local symbol value.  R_SYM is the index of a local
2088
// symbol in symbol table.  LV points to a symbol value, which is
2089
// expected to hold the input value and to be over-written by the
2090
// final value.  SYMTAB points to a symbol table.  Some targets may want
2091
// to know would-be-finalized local symbol values in relaxation.
2092
// Hence we provide this method.  Since this method updates *LV, a
2093
// callee should make a copy of the original local symbol value and
2094
// use the copy instead of modifying an object's local symbols before
2095
// everything is finalized.  The caller should also free up any allocated
2096
// memory in the return value in *LV.
2097
template<int size, bool big_endian>
2098
typename Sized_relobj_file<size, big_endian>::Compute_final_local_value_status
2099
Sized_relobj_file<size, big_endian>::compute_final_local_value(
2100
    unsigned int r_sym,
2101
    const Symbol_value<size>* lv_in,
2102
    Symbol_value<size>* lv_out,
2103
    const Symbol_table* symtab)
2104
{
2105
  // This is just a wrapper of compute_final_local_value_internal.
2106
  const bool relocatable = parameters->options().relocatable();
2107
  const Output_sections& out_sections(this->output_sections());
2108
  const std::vector<Address>& out_offsets(this->section_offsets());
2109
  return this->compute_final_local_value_internal(r_sym, lv_in, lv_out,
2110
                                                  relocatable, out_sections,
2111
                                                  out_offsets, symtab);
2112
}
2113
 
2114
// Finalize the local symbols.  Here we set the final value in
2115
// THIS->LOCAL_VALUES_ and set their output symbol table indexes.
2116
// This function is always called from a singleton thread.  The actual
2117
// output of the local symbols will occur in a separate task.
2118
 
2119
template<int size, bool big_endian>
2120
unsigned int
2121
Sized_relobj_file<size, big_endian>::do_finalize_local_symbols(
2122
    unsigned int index,
2123
    off_t off,
2124
    Symbol_table* symtab)
2125
{
2126
  gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
2127
 
2128
  const unsigned int loccount = this->local_symbol_count_;
2129
  this->local_symbol_offset_ = off;
2130
 
2131
  const bool relocatable = parameters->options().relocatable();
2132
  const Output_sections& out_sections(this->output_sections());
2133
  const std::vector<Address>& out_offsets(this->section_offsets());
2134
 
2135
  for (unsigned int i = 1; i < loccount; ++i)
2136
    {
2137
      Symbol_value<size>* lv = &this->local_values_[i];
2138
 
2139
      Compute_final_local_value_status cflv_status =
2140
        this->compute_final_local_value_internal(i, lv, lv, relocatable,
2141
                                                 out_sections, out_offsets,
2142
                                                 symtab);
2143
      switch (cflv_status)
2144
        {
2145
        case CFLV_OK:
2146
          if (!lv->is_output_symtab_index_set())
2147
            {
2148
              lv->set_output_symtab_index(index);
2149
              ++index;
2150
            }
2151
          break;
2152
        case CFLV_DISCARDED:
2153
        case CFLV_ERROR:
2154
          // Do nothing.
2155
          break;
2156
        default:
2157
          gold_unreachable();
2158
        }
2159
    }
2160
  return index;
2161
}
2162
 
2163
// Set the output dynamic symbol table indexes for the local variables.
2164
 
2165
template<int size, bool big_endian>
2166
unsigned int
2167
Sized_relobj_file<size, big_endian>::do_set_local_dynsym_indexes(
2168
    unsigned int index)
2169
{
2170
  const unsigned int loccount = this->local_symbol_count_;
2171
  for (unsigned int i = 1; i < loccount; ++i)
2172
    {
2173
      Symbol_value<size>& lv(this->local_values_[i]);
2174
      if (lv.needs_output_dynsym_entry())
2175
        {
2176
          lv.set_output_dynsym_index(index);
2177
          ++index;
2178
        }
2179
    }
2180
  return index;
2181
}
2182
 
2183
// Set the offset where local dynamic symbol information will be stored.
2184
// Returns the count of local symbols contributed to the symbol table by
2185
// this object.
2186
 
2187
template<int size, bool big_endian>
2188
unsigned int
2189
Sized_relobj_file<size, big_endian>::do_set_local_dynsym_offset(off_t off)
2190
{
2191
  gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
2192
  this->local_dynsym_offset_ = off;
2193
  return this->output_local_dynsym_count_;
2194
}
2195
 
2196
// If Symbols_data is not NULL get the section flags from here otherwise
2197
// get it from the file.
2198
 
2199
template<int size, bool big_endian>
2200
uint64_t
2201
Sized_relobj_file<size, big_endian>::do_section_flags(unsigned int shndx)
2202
{
2203
  Symbols_data* sd = this->get_symbols_data();
2204
  if (sd != NULL)
2205
    {
2206
      const unsigned char* pshdrs = sd->section_headers_data
2207
                                    + This::shdr_size * shndx;
2208
      typename This::Shdr shdr(pshdrs);
2209
      return shdr.get_sh_flags();
2210
    }
2211
  // If sd is NULL, read the section header from the file.
2212
  return this->elf_file_.section_flags(shndx);
2213
}
2214
 
2215
// Get the section's ent size from Symbols_data.  Called by get_section_contents
2216
// in icf.cc
2217
 
2218
template<int size, bool big_endian>
2219
uint64_t
2220
Sized_relobj_file<size, big_endian>::do_section_entsize(unsigned int shndx)
2221
{
2222
  Symbols_data* sd = this->get_symbols_data();
2223
  gold_assert(sd != NULL);
2224
 
2225
  const unsigned char* pshdrs = sd->section_headers_data
2226
                                + This::shdr_size * shndx;
2227
  typename This::Shdr shdr(pshdrs);
2228
  return shdr.get_sh_entsize();
2229
}
2230
 
2231
// Write out the local symbols.
2232
 
2233
template<int size, bool big_endian>
2234
void
2235
Sized_relobj_file<size, big_endian>::write_local_symbols(
2236
    Output_file* of,
2237
    const Stringpool* sympool,
2238
    const Stringpool* dynpool,
2239
    Output_symtab_xindex* symtab_xindex,
2240
    Output_symtab_xindex* dynsym_xindex,
2241
    off_t symtab_off)
2242
{
2243
  const bool strip_all = parameters->options().strip_all();
2244
  if (strip_all)
2245
    {
2246
      if (this->output_local_dynsym_count_ == 0)
2247
        return;
2248
      this->output_local_symbol_count_ = 0;
2249
    }
2250
 
2251
  gold_assert(this->symtab_shndx_ != -1U);
2252
  if (this->symtab_shndx_ == 0)
2253
    {
2254
      // This object has no symbols.  Weird but legal.
2255
      return;
2256
    }
2257
 
2258
  // Read the symbol table section header.
2259
  const unsigned int symtab_shndx = this->symtab_shndx_;
2260
  typename This::Shdr symtabshdr(this,
2261
                                 this->elf_file_.section_header(symtab_shndx));
2262
  gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
2263
  const unsigned int loccount = this->local_symbol_count_;
2264
  gold_assert(loccount == symtabshdr.get_sh_info());
2265
 
2266
  // Read the local symbols.
2267
  const int sym_size = This::sym_size;
2268
  off_t locsize = loccount * sym_size;
2269
  const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
2270
                                              locsize, true, false);
2271
 
2272
  // Read the symbol names.
2273
  const unsigned int strtab_shndx =
2274
    this->adjust_shndx(symtabshdr.get_sh_link());
2275
  section_size_type strtab_size;
2276
  const unsigned char* pnamesu = this->section_contents(strtab_shndx,
2277
                                                        &strtab_size,
2278
                                                        false);
2279
  const char* pnames = reinterpret_cast<const char*>(pnamesu);
2280
 
2281
  // Get views into the output file for the portions of the symbol table
2282
  // and the dynamic symbol table that we will be writing.
2283
  off_t output_size = this->output_local_symbol_count_ * sym_size;
2284
  unsigned char* oview = NULL;
2285
  if (output_size > 0)
2286
    oview = of->get_output_view(symtab_off + this->local_symbol_offset_,
2287
                                output_size);
2288
 
2289
  off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size;
2290
  unsigned char* dyn_oview = NULL;
2291
  if (dyn_output_size > 0)
2292
    dyn_oview = of->get_output_view(this->local_dynsym_offset_,
2293
                                    dyn_output_size);
2294
 
2295
  const Output_sections out_sections(this->output_sections());
2296
 
2297
  gold_assert(this->local_values_.size() == loccount);
2298
 
2299
  unsigned char* ov = oview;
2300
  unsigned char* dyn_ov = dyn_oview;
2301
  psyms += sym_size;
2302
  for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size)
2303
    {
2304
      elfcpp::Sym<size, big_endian> isym(psyms);
2305
 
2306
      Symbol_value<size>& lv(this->local_values_[i]);
2307
 
2308
      bool is_ordinary;
2309
      unsigned int st_shndx = this->adjust_sym_shndx(i, isym.get_st_shndx(),
2310
                                                     &is_ordinary);
2311
      if (is_ordinary)
2312
        {
2313
          gold_assert(st_shndx < out_sections.size());
2314
          if (out_sections[st_shndx] == NULL)
2315
            continue;
2316
          st_shndx = out_sections[st_shndx]->out_shndx();
2317
          if (st_shndx >= elfcpp::SHN_LORESERVE)
2318
            {
2319
              if (lv.has_output_symtab_entry())
2320
                symtab_xindex->add(lv.output_symtab_index(), st_shndx);
2321
              if (lv.has_output_dynsym_entry())
2322
                dynsym_xindex->add(lv.output_dynsym_index(), st_shndx);
2323
              st_shndx = elfcpp::SHN_XINDEX;
2324
            }
2325
        }
2326
 
2327
      // Write the symbol to the output symbol table.
2328
      if (lv.has_output_symtab_entry())
2329
        {
2330
          elfcpp::Sym_write<size, big_endian> osym(ov);
2331
 
2332
          gold_assert(isym.get_st_name() < strtab_size);
2333
          const char* name = pnames + isym.get_st_name();
2334
          osym.put_st_name(sympool->get_offset(name));
2335
          osym.put_st_value(this->local_values_[i].value(this, 0));
2336
          osym.put_st_size(isym.get_st_size());
2337
          osym.put_st_info(isym.get_st_info());
2338
          osym.put_st_other(isym.get_st_other());
2339
          osym.put_st_shndx(st_shndx);
2340
 
2341
          ov += sym_size;
2342
        }
2343
 
2344
      // Write the symbol to the output dynamic symbol table.
2345
      if (lv.has_output_dynsym_entry())
2346
        {
2347
          gold_assert(dyn_ov < dyn_oview + dyn_output_size);
2348
          elfcpp::Sym_write<size, big_endian> osym(dyn_ov);
2349
 
2350
          gold_assert(isym.get_st_name() < strtab_size);
2351
          const char* name = pnames + isym.get_st_name();
2352
          osym.put_st_name(dynpool->get_offset(name));
2353
          osym.put_st_value(this->local_values_[i].value(this, 0));
2354
          osym.put_st_size(isym.get_st_size());
2355
          osym.put_st_info(isym.get_st_info());
2356
          osym.put_st_other(isym.get_st_other());
2357
          osym.put_st_shndx(st_shndx);
2358
 
2359
          dyn_ov += sym_size;
2360
        }
2361
    }
2362
 
2363
 
2364
  if (output_size > 0)
2365
    {
2366
      gold_assert(ov - oview == output_size);
2367
      of->write_output_view(symtab_off + this->local_symbol_offset_,
2368
                            output_size, oview);
2369
    }
2370
 
2371
  if (dyn_output_size > 0)
2372
    {
2373
      gold_assert(dyn_ov - dyn_oview == dyn_output_size);
2374
      of->write_output_view(this->local_dynsym_offset_, dyn_output_size,
2375
                            dyn_oview);
2376
    }
2377
}
2378
 
2379
// Set *INFO to symbolic information about the offset OFFSET in the
2380
// section SHNDX.  Return true if we found something, false if we
2381
// found nothing.
2382
 
2383
template<int size, bool big_endian>
2384
bool
2385
Sized_relobj_file<size, big_endian>::get_symbol_location_info(
2386
    unsigned int shndx,
2387
    off_t offset,
2388
    Symbol_location_info* info)
2389
{
2390
  if (this->symtab_shndx_ == 0)
2391
    return false;
2392
 
2393
  section_size_type symbols_size;
2394
  const unsigned char* symbols = this->section_contents(this->symtab_shndx_,
2395
                                                        &symbols_size,
2396
                                                        false);
2397
 
2398
  unsigned int symbol_names_shndx =
2399
    this->adjust_shndx(this->section_link(this->symtab_shndx_));
2400
  section_size_type names_size;
2401
  const unsigned char* symbol_names_u =
2402
    this->section_contents(symbol_names_shndx, &names_size, false);
2403
  const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u);
2404
 
2405
  const int sym_size = This::sym_size;
2406
  const size_t count = symbols_size / sym_size;
2407
 
2408
  const unsigned char* p = symbols;
2409
  for (size_t i = 0; i < count; ++i, p += sym_size)
2410
    {
2411
      elfcpp::Sym<size, big_endian> sym(p);
2412
 
2413
      if (sym.get_st_type() == elfcpp::STT_FILE)
2414
        {
2415
          if (sym.get_st_name() >= names_size)
2416
            info->source_file = "(invalid)";
2417
          else
2418
            info->source_file = symbol_names + sym.get_st_name();
2419
          continue;
2420
        }
2421
 
2422
      bool is_ordinary;
2423
      unsigned int st_shndx = this->adjust_sym_shndx(i, sym.get_st_shndx(),
2424
                                                     &is_ordinary);
2425
      if (is_ordinary
2426
          && st_shndx == shndx
2427
          && static_cast<off_t>(sym.get_st_value()) <= offset
2428
          && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size())
2429
              > offset))
2430
        {
2431
          if (sym.get_st_name() > names_size)
2432
            info->enclosing_symbol_name = "(invalid)";
2433
          else
2434
            {
2435
              info->enclosing_symbol_name = symbol_names + sym.get_st_name();
2436
              if (parameters->options().do_demangle())
2437
                {
2438
                  char* demangled_name = cplus_demangle(
2439
                      info->enclosing_symbol_name.c_str(),
2440
                      DMGL_ANSI | DMGL_PARAMS);
2441
                  if (demangled_name != NULL)
2442
                    {
2443
                      info->enclosing_symbol_name.assign(demangled_name);
2444
                      free(demangled_name);
2445
                    }
2446
                }
2447
            }
2448
          return true;
2449
        }
2450
    }
2451
 
2452
  return false;
2453
}
2454
 
2455
// Look for a kept section corresponding to the given discarded section,
2456
// and return its output address.  This is used only for relocations in
2457
// debugging sections.  If we can't find the kept section, return 0.
2458
 
2459
template<int size, bool big_endian>
2460
typename Sized_relobj_file<size, big_endian>::Address
2461
Sized_relobj_file<size, big_endian>::map_to_kept_section(
2462
    unsigned int shndx,
2463
    bool* found) const
2464
{
2465
  Relobj* kept_object;
2466
  unsigned int kept_shndx;
2467
  if (this->get_kept_comdat_section(shndx, &kept_object, &kept_shndx))
2468
    {
2469
      Sized_relobj_file<size, big_endian>* kept_relobj =
2470
        static_cast<Sized_relobj_file<size, big_endian>*>(kept_object);
2471
      Output_section* os = kept_relobj->output_section(kept_shndx);
2472
      Address offset = kept_relobj->get_output_section_offset(kept_shndx);
2473
      if (os != NULL && offset != invalid_address)
2474
        {
2475
          *found = true;
2476
          return os->address() + offset;
2477
        }
2478
    }
2479
  *found = false;
2480
  return 0;
2481
}
2482
 
2483
// Get symbol counts.
2484
 
2485
template<int size, bool big_endian>
2486
void
2487
Sized_relobj_file<size, big_endian>::do_get_global_symbol_counts(
2488
    const Symbol_table*,
2489
    size_t* defined,
2490
    size_t* used) const
2491
{
2492
  *defined = this->defined_count_;
2493
  size_t count = 0;
2494
  for (typename Symbols::const_iterator p = this->symbols_.begin();
2495
       p != this->symbols_.end();
2496
       ++p)
2497
    if (*p != NULL
2498
        && (*p)->source() == Symbol::FROM_OBJECT
2499
        && (*p)->object() == this
2500
        && (*p)->is_defined())
2501
      ++count;
2502
  *used = count;
2503
}
2504
 
2505
// Input_objects methods.
2506
 
2507
// Add a regular relocatable object to the list.  Return false if this
2508
// object should be ignored.
2509
 
2510
bool
2511
Input_objects::add_object(Object* obj)
2512
{
2513
  // Print the filename if the -t/--trace option is selected.
2514
  if (parameters->options().trace())
2515
    gold_info("%s", obj->name().c_str());
2516
 
2517
  if (!obj->is_dynamic())
2518
    this->relobj_list_.push_back(static_cast<Relobj*>(obj));
2519
  else
2520
    {
2521
      // See if this is a duplicate SONAME.
2522
      Dynobj* dynobj = static_cast<Dynobj*>(obj);
2523
      const char* soname = dynobj->soname();
2524
 
2525
      std::pair<Unordered_set<std::string>::iterator, bool> ins =
2526
        this->sonames_.insert(soname);
2527
      if (!ins.second)
2528
        {
2529
          // We have already seen a dynamic object with this soname.
2530
          return false;
2531
        }
2532
 
2533
      this->dynobj_list_.push_back(dynobj);
2534
    }
2535
 
2536
  // Add this object to the cross-referencer if requested.
2537
  if (parameters->options().user_set_print_symbol_counts()
2538
      || parameters->options().cref())
2539
    {
2540
      if (this->cref_ == NULL)
2541
        this->cref_ = new Cref();
2542
      this->cref_->add_object(obj);
2543
    }
2544
 
2545
  return true;
2546
}
2547
 
2548
// For each dynamic object, record whether we've seen all of its
2549
// explicit dependencies.
2550
 
2551
void
2552
Input_objects::check_dynamic_dependencies() const
2553
{
2554
  bool issued_copy_dt_needed_error = false;
2555
  for (Dynobj_list::const_iterator p = this->dynobj_list_.begin();
2556
       p != this->dynobj_list_.end();
2557
       ++p)
2558
    {
2559
      const Dynobj::Needed& needed((*p)->needed());
2560
      bool found_all = true;
2561
      Dynobj::Needed::const_iterator pneeded;
2562
      for (pneeded = needed.begin(); pneeded != needed.end(); ++pneeded)
2563
        {
2564
          if (this->sonames_.find(*pneeded) == this->sonames_.end())
2565
            {
2566
              found_all = false;
2567
              break;
2568
            }
2569
        }
2570
      (*p)->set_has_unknown_needed_entries(!found_all);
2571
 
2572
      // --copy-dt-needed-entries aka --add-needed is a GNU ld option
2573
      // that gold does not support.  However, they cause no trouble
2574
      // unless there is a DT_NEEDED entry that we don't know about;
2575
      // warn only in that case.
2576
      if (!found_all
2577
          && !issued_copy_dt_needed_error
2578
          && (parameters->options().copy_dt_needed_entries()
2579
              || parameters->options().add_needed()))
2580
        {
2581
          const char* optname;
2582
          if (parameters->options().copy_dt_needed_entries())
2583
            optname = "--copy-dt-needed-entries";
2584
          else
2585
            optname = "--add-needed";
2586
          gold_error(_("%s is not supported but is required for %s in %s"),
2587
                     optname, (*pneeded).c_str(), (*p)->name().c_str());
2588
          issued_copy_dt_needed_error = true;
2589
        }
2590
    }
2591
}
2592
 
2593
// Start processing an archive.
2594
 
2595
void
2596
Input_objects::archive_start(Archive* archive)
2597
{
2598
  if (parameters->options().user_set_print_symbol_counts()
2599
      || parameters->options().cref())
2600
    {
2601
      if (this->cref_ == NULL)
2602
        this->cref_ = new Cref();
2603
      this->cref_->add_archive_start(archive);
2604
    }
2605
}
2606
 
2607
// Stop processing an archive.
2608
 
2609
void
2610
Input_objects::archive_stop(Archive* archive)
2611
{
2612
  if (parameters->options().user_set_print_symbol_counts()
2613
      || parameters->options().cref())
2614
    this->cref_->add_archive_stop(archive);
2615
}
2616
 
2617
// Print symbol counts
2618
 
2619
void
2620
Input_objects::print_symbol_counts(const Symbol_table* symtab) const
2621
{
2622
  if (parameters->options().user_set_print_symbol_counts()
2623
      && this->cref_ != NULL)
2624
    this->cref_->print_symbol_counts(symtab);
2625
}
2626
 
2627
// Print a cross reference table.
2628
 
2629
void
2630
Input_objects::print_cref(const Symbol_table* symtab, FILE* f) const
2631
{
2632
  if (parameters->options().cref() && this->cref_ != NULL)
2633
    this->cref_->print_cref(symtab, f);
2634
}
2635
 
2636
// Relocate_info methods.
2637
 
2638
// Return a string describing the location of a relocation when file
2639
// and lineno information is not available.  This is only used in
2640
// error messages.
2641
 
2642
template<int size, bool big_endian>
2643
std::string
2644
Relocate_info<size, big_endian>::location(size_t, off_t offset) const
2645
{
2646
  Sized_dwarf_line_info<size, big_endian> line_info(this->object);
2647
  std::string ret = line_info.addr2line(this->data_shndx, offset, NULL);
2648
  if (!ret.empty())
2649
    return ret;
2650
 
2651
  ret = this->object->name();
2652
 
2653
  Symbol_location_info info;
2654
  if (this->object->get_symbol_location_info(this->data_shndx, offset, &info))
2655
    {
2656
      if (!info.source_file.empty())
2657
        {
2658
          ret += ":";
2659
          ret += info.source_file;
2660
        }
2661
      size_t len = info.enclosing_symbol_name.length() + 100;
2662
      char* buf = new char[len];
2663
      snprintf(buf, len, _(":function %s"),
2664
               info.enclosing_symbol_name.c_str());
2665
      ret += buf;
2666
      delete[] buf;
2667
      return ret;
2668
    }
2669
 
2670
  ret += "(";
2671
  ret += this->object->section_name(this->data_shndx);
2672
  char buf[100];
2673
  snprintf(buf, sizeof buf, "+0x%lx)", static_cast<long>(offset));
2674
  ret += buf;
2675
  return ret;
2676
}
2677
 
2678
} // End namespace gold.
2679
 
2680
namespace
2681
{
2682
 
2683
using namespace gold;
2684
 
2685
// Read an ELF file with the header and return the appropriate
2686
// instance of Object.
2687
 
2688
template<int size, bool big_endian>
2689
Object*
2690
make_elf_sized_object(const std::string& name, Input_file* input_file,
2691
                      off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr,
2692
                      bool* punconfigured)
2693
{
2694
  Target* target = select_target(ehdr.get_e_machine(), size, big_endian,
2695
                                 ehdr.get_e_ident()[elfcpp::EI_OSABI],
2696
                                 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
2697
  if (target == NULL)
2698
    gold_fatal(_("%s: unsupported ELF machine number %d"),
2699
               name.c_str(), ehdr.get_e_machine());
2700
 
2701
  if (!parameters->target_valid())
2702
    set_parameters_target(target);
2703
  else if (target != &parameters->target())
2704
    {
2705
      if (punconfigured != NULL)
2706
        *punconfigured = true;
2707
      else
2708
        gold_error(_("%s: incompatible target"), name.c_str());
2709
      return NULL;
2710
    }
2711
 
2712
  return target->make_elf_object<size, big_endian>(name, input_file, offset,
2713
                                                   ehdr);
2714
}
2715
 
2716
} // End anonymous namespace.
2717
 
2718
namespace gold
2719
{
2720
 
2721
// Return whether INPUT_FILE is an ELF object.
2722
 
2723
bool
2724
is_elf_object(Input_file* input_file, off_t offset,
2725
              const unsigned char** start, int* read_size)
2726
{
2727
  off_t filesize = input_file->file().filesize();
2728
  int want = elfcpp::Elf_recognizer::max_header_size;
2729
  if (filesize - offset < want)
2730
    want = filesize - offset;
2731
 
2732
  const unsigned char* p = input_file->file().get_view(offset, 0, want,
2733
                                                       true, false);
2734
  *start = p;
2735
  *read_size = want;
2736
 
2737
  return elfcpp::Elf_recognizer::is_elf_file(p, want);
2738
}
2739
 
2740
// Read an ELF file and return the appropriate instance of Object.
2741
 
2742
Object*
2743
make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
2744
                const unsigned char* p, section_offset_type bytes,
2745
                bool* punconfigured)
2746
{
2747
  if (punconfigured != NULL)
2748
    *punconfigured = false;
2749
 
2750
  std::string error;
2751
  bool big_endian = false;
2752
  int size = 0;
2753
  if (!elfcpp::Elf_recognizer::is_valid_header(p, bytes, &size,
2754
                                               &big_endian, &error))
2755
    {
2756
      gold_error(_("%s: %s"), name.c_str(), error.c_str());
2757
      return NULL;
2758
    }
2759
 
2760
  if (size == 32)
2761
    {
2762
      if (big_endian)
2763
        {
2764
#ifdef HAVE_TARGET_32_BIG
2765
          elfcpp::Ehdr<32, true> ehdr(p);
2766
          return make_elf_sized_object<32, true>(name, input_file,
2767
                                                 offset, ehdr, punconfigured);
2768
#else
2769
          if (punconfigured != NULL)
2770
            *punconfigured = true;
2771
          else
2772
            gold_error(_("%s: not configured to support "
2773
                         "32-bit big-endian object"),
2774
                       name.c_str());
2775
          return NULL;
2776
#endif
2777
        }
2778
      else
2779
        {
2780
#ifdef HAVE_TARGET_32_LITTLE
2781
          elfcpp::Ehdr<32, false> ehdr(p);
2782
          return make_elf_sized_object<32, false>(name, input_file,
2783
                                                  offset, ehdr, punconfigured);
2784
#else
2785
          if (punconfigured != NULL)
2786
            *punconfigured = true;
2787
          else
2788
            gold_error(_("%s: not configured to support "
2789
                         "32-bit little-endian object"),
2790
                       name.c_str());
2791
          return NULL;
2792
#endif
2793
        }
2794
    }
2795
  else if (size == 64)
2796
    {
2797
      if (big_endian)
2798
        {
2799
#ifdef HAVE_TARGET_64_BIG
2800
          elfcpp::Ehdr<64, true> ehdr(p);
2801
          return make_elf_sized_object<64, true>(name, input_file,
2802
                                                 offset, ehdr, punconfigured);
2803
#else
2804
          if (punconfigured != NULL)
2805
            *punconfigured = true;
2806
          else
2807
            gold_error(_("%s: not configured to support "
2808
                         "64-bit big-endian object"),
2809
                       name.c_str());
2810
          return NULL;
2811
#endif
2812
        }
2813
      else
2814
        {
2815
#ifdef HAVE_TARGET_64_LITTLE
2816
          elfcpp::Ehdr<64, false> ehdr(p);
2817
          return make_elf_sized_object<64, false>(name, input_file,
2818
                                                  offset, ehdr, punconfigured);
2819
#else
2820
          if (punconfigured != NULL)
2821
            *punconfigured = true;
2822
          else
2823
            gold_error(_("%s: not configured to support "
2824
                         "64-bit little-endian object"),
2825
                       name.c_str());
2826
          return NULL;
2827
#endif
2828
        }
2829
    }
2830
  else
2831
    gold_unreachable();
2832
}
2833
 
2834
// Instantiate the templates we need.
2835
 
2836
#ifdef HAVE_TARGET_32_LITTLE
2837
template
2838
void
2839
Object::read_section_data<32, false>(elfcpp::Elf_file<32, false, Object>*,
2840
                                     Read_symbols_data*);
2841
#endif
2842
 
2843
#ifdef HAVE_TARGET_32_BIG
2844
template
2845
void
2846
Object::read_section_data<32, true>(elfcpp::Elf_file<32, true, Object>*,
2847
                                    Read_symbols_data*);
2848
#endif
2849
 
2850
#ifdef HAVE_TARGET_64_LITTLE
2851
template
2852
void
2853
Object::read_section_data<64, false>(elfcpp::Elf_file<64, false, Object>*,
2854
                                     Read_symbols_data*);
2855
#endif
2856
 
2857
#ifdef HAVE_TARGET_64_BIG
2858
template
2859
void
2860
Object::read_section_data<64, true>(elfcpp::Elf_file<64, true, Object>*,
2861
                                    Read_symbols_data*);
2862
#endif
2863
 
2864
#ifdef HAVE_TARGET_32_LITTLE
2865
template
2866
class Sized_relobj_file<32, false>;
2867
#endif
2868
 
2869
#ifdef HAVE_TARGET_32_BIG
2870
template
2871
class Sized_relobj_file<32, true>;
2872
#endif
2873
 
2874
#ifdef HAVE_TARGET_64_LITTLE
2875
template
2876
class Sized_relobj_file<64, false>;
2877
#endif
2878
 
2879
#ifdef HAVE_TARGET_64_BIG
2880
template
2881
class Sized_relobj_file<64, true>;
2882
#endif
2883
 
2884
#ifdef HAVE_TARGET_32_LITTLE
2885
template
2886
struct Relocate_info<32, false>;
2887
#endif
2888
 
2889
#ifdef HAVE_TARGET_32_BIG
2890
template
2891
struct Relocate_info<32, true>;
2892
#endif
2893
 
2894
#ifdef HAVE_TARGET_64_LITTLE
2895
template
2896
struct Relocate_info<64, false>;
2897
#endif
2898
 
2899
#ifdef HAVE_TARGET_64_BIG
2900
template
2901
struct Relocate_info<64, true>;
2902
#endif
2903
 
2904
#ifdef HAVE_TARGET_32_LITTLE
2905
template
2906
void
2907
Xindex::initialize_symtab_xindex<32, false>(Object*, unsigned int);
2908
 
2909
template
2910
void
2911
Xindex::read_symtab_xindex<32, false>(Object*, unsigned int,
2912
                                      const unsigned char*);
2913
#endif
2914
 
2915
#ifdef HAVE_TARGET_32_BIG
2916
template
2917
void
2918
Xindex::initialize_symtab_xindex<32, true>(Object*, unsigned int);
2919
 
2920
template
2921
void
2922
Xindex::read_symtab_xindex<32, true>(Object*, unsigned int,
2923
                                     const unsigned char*);
2924
#endif
2925
 
2926
#ifdef HAVE_TARGET_64_LITTLE
2927
template
2928
void
2929
Xindex::initialize_symtab_xindex<64, false>(Object*, unsigned int);
2930
 
2931
template
2932
void
2933
Xindex::read_symtab_xindex<64, false>(Object*, unsigned int,
2934
                                      const unsigned char*);
2935
#endif
2936
 
2937
#ifdef HAVE_TARGET_64_BIG
2938
template
2939
void
2940
Xindex::initialize_symtab_xindex<64, true>(Object*, unsigned int);
2941
 
2942
template
2943
void
2944
Xindex::read_symtab_xindex<64, true>(Object*, unsigned int,
2945
                                     const unsigned char*);
2946
#endif
2947
 
2948
} // End namespace gold.

powered by: WebSVN 2.1.0

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