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