Merge branch 'vendor/BZIP'
[dragonfly.git] / contrib / binutils-2.20 / gold / object.h
1 // object.h -- support for an object file for linking in gold  -*- C++ -*-
2
3 // Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of gold.
7
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
12
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 // GNU General Public License for more details.
17
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
22
23 #ifndef GOLD_OBJECT_H
24 #define GOLD_OBJECT_H
25
26 #include <string>
27 #include <vector>
28
29 #include "elfcpp.h"
30 #include "elfcpp_file.h"
31 #include "fileread.h"
32 #include "target.h"
33
34 namespace gold
35 {
36
37 class General_options;
38 class Task;
39 class Cref;
40 class Archive;
41 class Layout;
42 class Output_section;
43 class Output_file;
44 class Output_symtab_xindex;
45 class Pluginobj;
46 class Dynobj;
47 class Object_merge_map;
48 class Relocatable_relocs;
49 class Symbols_data;
50
51 template<typename Stringpool_char>
52 class Stringpool_template;
53
54 // Data to pass from read_symbols() to add_symbols().
55
56 struct Read_symbols_data
57 {
58   // Section headers.
59   File_view* section_headers;
60   // Section names.
61   File_view* section_names;
62   // Size of section name data in bytes.
63   section_size_type section_names_size;
64   // Symbol data.
65   File_view* symbols;
66   // Size of symbol data in bytes.
67   section_size_type symbols_size;
68   // Offset of external symbols within symbol data.  This structure
69   // sometimes contains only external symbols, in which case this will
70   // be zero.  Sometimes it contains all symbols.
71   section_offset_type external_symbols_offset;
72   // Symbol names.
73   File_view* symbol_names;
74   // Size of symbol name data in bytes.
75   section_size_type symbol_names_size;
76
77   // Version information.  This is only used on dynamic objects.
78   // Version symbol data (from SHT_GNU_versym section).
79   File_view* versym;
80   section_size_type versym_size;
81   // Version definition data (from SHT_GNU_verdef section).
82   File_view* verdef;
83   section_size_type verdef_size;
84   unsigned int verdef_info;
85   // Needed version data  (from SHT_GNU_verneed section).
86   File_view* verneed;
87   section_size_type verneed_size;
88   unsigned int verneed_info;
89 };
90
91 // Information used to print error messages.
92
93 struct Symbol_location_info
94 {
95   std::string source_file;
96   std::string enclosing_symbol_name;
97   int line_number;
98 };
99
100 // Data about a single relocation section.  This is read in
101 // read_relocs and processed in scan_relocs.
102
103 struct Section_relocs
104 {
105   // Index of reloc section.
106   unsigned int reloc_shndx;
107   // Index of section that relocs apply to.
108   unsigned int data_shndx;
109   // Contents of reloc section.
110   File_view* contents;
111   // Reloc section type.
112   unsigned int sh_type;
113   // Number of reloc entries.
114   size_t reloc_count;
115   // Output section.
116   Output_section* output_section;
117   // Whether this section has special handling for offsets.
118   bool needs_special_offset_handling;
119   // Whether the data section is allocated (has the SHF_ALLOC flag set).
120   bool is_data_section_allocated;
121 };
122
123 // Relocations in an object file.  This is read in read_relocs and
124 // processed in scan_relocs.
125
126 struct Read_relocs_data
127 {
128   typedef std::vector<Section_relocs> Relocs_list;
129   // The relocations.
130   Relocs_list relocs;
131   // The local symbols.
132   File_view* local_symbols;
133 };
134
135 // The Xindex class manages section indexes for objects with more than
136 // 0xff00 sections.
137
138 class Xindex
139 {
140  public:
141   Xindex(int large_shndx_offset)
142     : large_shndx_offset_(large_shndx_offset), symtab_xindex_()
143   { }
144
145   // Initialize the symtab_xindex_ array, given the object and the
146   // section index of the symbol table to use.
147   template<int size, bool big_endian>
148   void
149   initialize_symtab_xindex(Object*, unsigned int symtab_shndx);
150
151   // Read in the symtab_xindex_ array, given its section index.
152   // PSHDRS may optionally point to the section headers.
153   template<int size, bool big_endian>
154   void
155   read_symtab_xindex(Object*, unsigned int xindex_shndx,
156                      const unsigned char* pshdrs);
157
158   // Symbol SYMNDX in OBJECT has a section of SHN_XINDEX; return the
159   // real section index.
160   unsigned int
161   sym_xindex_to_shndx(Object* object, unsigned int symndx);
162
163  private:
164   // The type of the array giving the real section index for symbols
165   // whose st_shndx field holds SHN_XINDEX.
166   typedef std::vector<unsigned int> Symtab_xindex;
167
168   // Adjust a section index if necessary.  This should only be called
169   // for ordinary section indexes.
170   unsigned int
171   adjust_shndx(unsigned int shndx)
172   {
173     if (shndx >= elfcpp::SHN_LORESERVE)
174       shndx += this->large_shndx_offset_;
175     return shndx;
176   }
177
178   // Adjust to apply to large section indexes.
179   int large_shndx_offset_;
180   // The data from the SHT_SYMTAB_SHNDX section.
181   Symtab_xindex symtab_xindex_;
182 };
183
184 // Object is an abstract base class which represents either a 32-bit
185 // or a 64-bit input object.  This can be a regular object file
186 // (ET_REL) or a shared object (ET_DYN).
187
188 class Object
189 {
190  public:
191   // NAME is the name of the object as we would report it to the user
192   // (e.g., libfoo.a(bar.o) if this is in an archive.  INPUT_FILE is
193   // used to read the file.  OFFSET is the offset within the input
194   // file--0 for a .o or .so file, something else for a .a file.
195   Object(const std::string& name, Input_file* input_file, bool is_dynamic,
196          off_t offset = 0)
197     : name_(name), input_file_(input_file), offset_(offset), shnum_(-1U),
198       is_dynamic_(is_dynamic), uses_split_stack_(false),
199       has_no_split_stack_(false), xindex_(NULL), no_export_(false)
200   { input_file->file().add_object(); }
201
202   virtual ~Object()
203   { this->input_file_->file().remove_object(); }
204
205   // Return the name of the object as we would report it to the tuser.
206   const std::string&
207   name() const
208   { return this->name_; }
209
210   // Get the offset into the file.
211   off_t
212   offset() const
213   { return this->offset_; }
214
215   // Return whether this is a dynamic object.
216   bool
217   is_dynamic() const
218   { return this->is_dynamic_; }
219
220   // Return whether this object was compiled with -fsplit-stack.
221   bool
222   uses_split_stack() const
223   { return this->uses_split_stack_; }
224
225   // Return whether this object contains any functions compiled with
226   // the no_split_stack attribute.
227   bool
228   has_no_split_stack() const
229   { return this->has_no_split_stack_; }
230
231   // Returns NULL for Objects that are not plugin objects.  This method
232   // is overridden in the Pluginobj class.
233   Pluginobj*
234   pluginobj()
235   { return this->do_pluginobj(); }
236
237   // Get the file.  We pass on const-ness.
238   Input_file*
239   input_file()
240   { return this->input_file_; }
241
242   const Input_file*
243   input_file() const
244   { return this->input_file_; }
245
246   // Lock the underlying file.
247   void
248   lock(const Task* t)
249   { this->input_file()->file().lock(t); }
250
251   // Unlock the underlying file.
252   void
253   unlock(const Task* t)
254   { this->input_file()->file().unlock(t); }
255
256   // Return whether the underlying file is locked.
257   bool
258   is_locked() const
259   { return this->input_file()->file().is_locked(); }
260
261   // Return the token, so that the task can be queued.
262   Task_token*
263   token()
264   { return this->input_file()->file().token(); }
265
266   // Release the underlying file.
267   void
268   release()
269   { this->input_file_->file().release(); }
270
271   // Return whether we should just read symbols from this file.
272   bool
273   just_symbols() const
274   { return this->input_file()->just_symbols(); }
275
276   // Get the number of sections.
277   unsigned int
278   shnum() const
279   { return this->shnum_; }
280
281   // Return a view of the contents of a section.  Set *PLEN to the
282   // size.  CACHE is a hint as in File_read::get_view.
283   const unsigned char*
284   section_contents(unsigned int shndx, section_size_type* plen, bool cache);
285
286   // Adjust a symbol's section index as needed.  SYMNDX is the index
287   // of the symbol and SHNDX is the symbol's section from
288   // get_st_shndx.  This returns the section index.  It sets
289   // *IS_ORDINARY to indicate whether this is a normal section index,
290   // rather than a special code between SHN_LORESERVE and
291   // SHN_HIRESERVE.
292   unsigned int
293   adjust_sym_shndx(unsigned int symndx, unsigned int shndx, bool* is_ordinary)
294   {
295     if (shndx < elfcpp::SHN_LORESERVE)
296       *is_ordinary = true;
297     else if (shndx == elfcpp::SHN_XINDEX)
298       {
299         if (this->xindex_ == NULL)
300           this->xindex_ = this->do_initialize_xindex();
301         shndx = this->xindex_->sym_xindex_to_shndx(this, symndx);
302         *is_ordinary = true;
303       }
304     else
305       *is_ordinary = false;
306     return shndx;
307   }
308
309   // Return the size of a section given a section index.
310   uint64_t
311   section_size(unsigned int shndx)
312   { return this->do_section_size(shndx); }
313
314   // Return the name of a section given a section index.
315   std::string
316   section_name(unsigned int shndx)
317   { return this->do_section_name(shndx); }
318
319   // Return the section flags given a section index.
320   uint64_t
321   section_flags(unsigned int shndx)
322   { return this->do_section_flags(shndx); }
323
324   // Return the section entsize given a section index.
325   uint64_t
326   section_entsize(unsigned int shndx)
327   { return this->do_section_entsize(shndx); }
328
329   // Return the section address given a section index.
330   uint64_t
331   section_address(unsigned int shndx)
332   { return this->do_section_address(shndx); }
333
334   // Return the section type given a section index.
335   unsigned int
336   section_type(unsigned int shndx)
337   { return this->do_section_type(shndx); }
338
339   // Return the section link field given a section index.
340   unsigned int
341   section_link(unsigned int shndx)
342   { return this->do_section_link(shndx); }
343
344   // Return the section info field given a section index.
345   unsigned int
346   section_info(unsigned int shndx)
347   { return this->do_section_info(shndx); }
348
349   // Return the required section alignment given a section index.
350   uint64_t
351   section_addralign(unsigned int shndx)
352   { return this->do_section_addralign(shndx); }
353
354   // Read the symbol information.
355   void
356   read_symbols(Read_symbols_data* sd)
357   { return this->do_read_symbols(sd); }
358
359   // Pass sections which should be included in the link to the Layout
360   // object, and record where the sections go in the output file.
361   void
362   layout(Symbol_table* symtab, Layout* layout, Read_symbols_data* sd)
363   { this->do_layout(symtab, layout, sd); }
364
365   // Add symbol information to the global symbol table.
366   void
367   add_symbols(Symbol_table* symtab, Read_symbols_data* sd, Layout *layout)
368   { this->do_add_symbols(symtab, sd, layout); }
369
370   // Functions and types for the elfcpp::Elf_file interface.  This
371   // permit us to use Object as the File template parameter for
372   // elfcpp::Elf_file.
373
374   // The View class is returned by view.  It must support a single
375   // method, data().  This is trivial, because get_view does what we
376   // need.
377   class View
378   {
379    public:
380     View(const unsigned char* p)
381       : p_(p)
382     { }
383
384     const unsigned char*
385     data() const
386     { return this->p_; }
387
388    private:
389     const unsigned char* p_;
390   };
391
392   // Return a View.
393   View
394   view(off_t file_offset, section_size_type data_size)
395   { return View(this->get_view(file_offset, data_size, true, true)); }
396
397   // Report an error.
398   void
399   error(const char* format, ...) const ATTRIBUTE_PRINTF_2;
400
401   // A location in the file.
402   struct Location
403   {
404     off_t file_offset;
405     off_t data_size;
406
407     Location(off_t fo, section_size_type ds)
408       : file_offset(fo), data_size(ds)
409     { }
410   };
411
412   // Get a View given a Location.
413   View view(Location loc)
414   { return View(this->get_view(loc.file_offset, loc.data_size, true, true)); }
415
416   // Get a view into the underlying file.
417   const unsigned char*
418   get_view(off_t start, section_size_type size, bool aligned, bool cache)
419   {
420     return this->input_file()->file().get_view(this->offset_, start, size,
421                                                aligned, cache);
422   }
423
424   // Get a lasting view into the underlying file.
425   File_view*
426   get_lasting_view(off_t start, section_size_type size, bool aligned,
427                    bool cache)
428   {
429     return this->input_file()->file().get_lasting_view(this->offset_, start,
430                                                        size, aligned, cache);
431   }
432
433   // Read data from the underlying file.
434   void
435   read(off_t start, section_size_type size, void* p)
436   { this->input_file()->file().read(start + this->offset_, size, p); }
437
438   // Read multiple data from the underlying file.
439   void
440   read_multiple(const File_read::Read_multiple& rm)
441   { this->input_file()->file().read_multiple(this->offset_, rm); }
442
443   // Stop caching views in the underlying file.
444   void
445   clear_view_cache_marks()
446   { this->input_file()->file().clear_view_cache_marks(); }
447
448   // Get the number of global symbols defined by this object, and the
449   // number of the symbols whose final definition came from this
450   // object.
451   void
452   get_global_symbol_counts(const Symbol_table* symtab, size_t* defined,
453                            size_t* used) const
454   { this->do_get_global_symbol_counts(symtab, defined, used); }
455
456   // Return whether this object was found in a system directory.
457   bool
458   is_in_system_directory() const
459   { return this->input_file()->is_in_system_directory(); }
460
461   // Return whether we found this object by searching a directory.
462   bool
463   searched_for() const
464   { return this->input_file()->will_search_for(); }
465
466   bool
467   no_export() const
468   { return this->no_export_; }
469
470   void
471   set_no_export(bool value)
472   { this->no_export_ = value; }
473
474  protected:
475   // Returns NULL for Objects that are not plugin objects.  This method
476   // is overridden in the Pluginobj class.
477   virtual Pluginobj*
478   do_pluginobj()
479   { return NULL; }
480
481   // Read the symbols--implemented by child class.
482   virtual void
483   do_read_symbols(Read_symbols_data*) = 0;
484
485   // Lay out sections--implemented by child class.
486   virtual void
487   do_layout(Symbol_table*, Layout*, Read_symbols_data*) = 0;
488
489   // Add symbol information to the global symbol table--implemented by
490   // child class.
491   virtual void
492   do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*) = 0;
493
494   // Return the location of the contents of a section.  Implemented by
495   // child class.
496   virtual Location
497   do_section_contents(unsigned int shndx) = 0;
498
499   // Get the size of a section--implemented by child class.
500   virtual uint64_t
501   do_section_size(unsigned int shndx) = 0;
502
503   // Get the name of a section--implemented by child class.
504   virtual std::string
505   do_section_name(unsigned int shndx) = 0;
506
507   // Get section flags--implemented by child class.
508   virtual uint64_t
509   do_section_flags(unsigned int shndx) = 0;
510
511   // Get section entsize--implemented by child class.
512   virtual uint64_t
513   do_section_entsize(unsigned int shndx) = 0;
514
515   // Get section address--implemented by child class.
516   virtual uint64_t
517   do_section_address(unsigned int shndx) = 0;
518
519   // Get section type--implemented by child class.
520   virtual unsigned int
521   do_section_type(unsigned int shndx) = 0;
522
523   // Get section link field--implemented by child class.
524   virtual unsigned int
525   do_section_link(unsigned int shndx) = 0;
526
527   // Get section info field--implemented by child class.
528   virtual unsigned int
529   do_section_info(unsigned int shndx) = 0;
530
531   // Get section alignment--implemented by child class.
532   virtual uint64_t
533   do_section_addralign(unsigned int shndx) = 0;
534
535   // Return the Xindex structure to use.
536   virtual Xindex*
537   do_initialize_xindex() = 0;
538
539   // Implement get_global_symbol_counts--implemented by child class.
540   virtual void
541   do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const = 0;
542
543   // Set the number of sections.
544   void
545   set_shnum(int shnum)
546   { this->shnum_ = shnum; }
547
548   // Functions used by both Sized_relobj and Sized_dynobj.
549
550   // Read the section data into a Read_symbols_data object.
551   template<int size, bool big_endian>
552   void
553   read_section_data(elfcpp::Elf_file<size, big_endian, Object>*,
554                     Read_symbols_data*);
555
556   // Let the child class initialize the xindex object directly.
557   void
558   set_xindex(Xindex* xindex)
559   {
560     gold_assert(this->xindex_ == NULL);
561     this->xindex_ = xindex;
562   }
563
564   // If NAME is the name of a special .gnu.warning section, arrange
565   // for the warning to be issued.  SHNDX is the section index.
566   // Return whether it is a warning section.
567   bool
568   handle_gnu_warning_section(const char* name, unsigned int shndx,
569                              Symbol_table*);
570
571   // If NAME is the name of the special section which indicates that
572   // this object was compiled with -fstack-split, mark it accordingly,
573   // and return true.  Otherwise return false.
574   bool
575   handle_split_stack_section(const char* name);
576
577  private:
578   // This class may not be copied.
579   Object(const Object&);
580   Object& operator=(const Object&);
581
582   // Name of object as printed to user.
583   std::string name_;
584   // For reading the file.
585   Input_file* input_file_;
586   // Offset within the file--0 for an object file, non-0 for an
587   // archive.
588   off_t offset_;
589   // Number of input sections.
590   unsigned int shnum_;
591   // Whether this is a dynamic object.
592   bool is_dynamic_;
593   // Whether this object was compiled with -fsplit-stack.
594   bool uses_split_stack_;
595   // Whether this object contains any functions compiled with the
596   // no_split_stack attribute.
597   bool has_no_split_stack_;
598   // Many sections for objects with more than SHN_LORESERVE sections.
599   Xindex* xindex_;
600   // True if exclude this object from automatic symbol export.
601   // This is used only for archive objects.
602   bool no_export_;
603 };
604
605 // A regular object (ET_REL).  This is an abstract base class itself.
606 // The implementation is the template class Sized_relobj.
607
608 class Relobj : public Object
609 {
610  public:
611   Relobj(const std::string& name, Input_file* input_file, off_t offset = 0)
612     : Object(name, input_file, false, offset),
613       output_sections_(),
614       map_to_relocatable_relocs_(NULL),
615       object_merge_map_(NULL),
616       relocs_must_follow_section_writes_(false),
617       sd_(NULL)
618   { }
619
620   // During garbage collection, the Read_symbols_data pass for 
621   // each object is stored as layout needs to be done after 
622   // reloc processing.
623   Symbols_data* 
624   get_symbols_data()
625   { return this->sd_; }
626
627   // Decides which section names have to be included in the worklist
628   // as roots.
629   bool
630   is_section_name_included(const char *name);
631  
632   void
633   copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
634                     unsigned int section_header_size);
635
636   void
637   set_symbols_data(Symbols_data* sd)
638   { this->sd_ = sd; }
639
640   // During garbage collection, the Read_relocs pass for all objects 
641   // is done before scanning the relocs.  In that case, this->rd_ is
642   // used to store the information from Read_relocs for each object.
643   // This data is also used to compute the list of relevant sections.
644   Read_relocs_data*
645   get_relocs_data()
646   { return this->rd_; }
647
648   void
649   set_relocs_data(Read_relocs_data* rd)
650   { this->rd_ = rd; }
651
652   virtual bool
653   is_output_section_offset_invalid(unsigned int shndx) const = 0;
654
655   // Read the relocs.
656   void
657   read_relocs(Read_relocs_data* rd)
658   { return this->do_read_relocs(rd); }
659
660   // Process the relocs, during garbage collection only.
661   void
662   gc_process_relocs(const General_options& options, Symbol_table* symtab,
663                     Layout* layout, Read_relocs_data* rd)
664   { return this->do_gc_process_relocs(options, symtab, layout, rd); }
665
666   // Scan the relocs and adjust the symbol table.
667   void
668   scan_relocs(const General_options& options, Symbol_table* symtab,
669               Layout* layout, Read_relocs_data* rd)
670   { return this->do_scan_relocs(options, symtab, layout, rd); }
671
672   // The number of local symbols in the input symbol table.
673   virtual unsigned int
674   local_symbol_count() const
675   { return this->do_local_symbol_count(); }
676
677   // Initial local symbol processing: count the number of local symbols
678   // in the output symbol table and dynamic symbol table; add local symbol
679   // names to *POOL and *DYNPOOL.
680   void
681   count_local_symbols(Stringpool_template<char>* pool,
682                       Stringpool_template<char>* dynpool)
683   { return this->do_count_local_symbols(pool, dynpool); }
684
685   // Set the values of the local symbols, set the output symbol table
686   // indexes for the local variables, and set the offset where local
687   // symbol information will be stored. Returns the new local symbol index.
688   unsigned int
689   finalize_local_symbols(unsigned int index, off_t off, Symbol_table* symtab)
690   { return this->do_finalize_local_symbols(index, off, symtab); }
691
692   // Set the output dynamic symbol table indexes for the local variables.
693   unsigned int
694   set_local_dynsym_indexes(unsigned int index)
695   { return this->do_set_local_dynsym_indexes(index); }
696
697   // Set the offset where local dynamic symbol information will be stored.
698   unsigned int
699   set_local_dynsym_offset(off_t off)
700   { return this->do_set_local_dynsym_offset(off); }
701
702   // Relocate the input sections and write out the local symbols.
703   void
704   relocate(const General_options& options, const Symbol_table* symtab,
705            const Layout* layout, Output_file* of)
706   { return this->do_relocate(options, symtab, layout, of); }
707
708   // Return whether an input section is being included in the link.
709   bool
710   is_section_included(unsigned int shndx) const
711   {
712     gold_assert(shndx < this->output_sections_.size());
713     return this->output_sections_[shndx] != NULL;
714   }
715
716   // Given a section index, return the corresponding Output_section.
717   // The return value will be NULL if the section is not included in
718   // the link.
719   Output_section*
720   output_section(unsigned int shndx) const
721   {
722     gold_assert(shndx < this->output_sections_.size());
723     return this->output_sections_[shndx];
724   }
725
726   // Given a section index, return the offset in the Output_section.
727   // The return value will be -1U if the section is specially mapped,
728   // such as a merge section.
729   uint64_t
730   output_section_offset(unsigned int shndx) const
731   { return this->do_output_section_offset(shndx); }
732
733   // Set the offset of an input section within its output section.
734   void
735   set_section_offset(unsigned int shndx, uint64_t off)
736   { this->do_set_section_offset(shndx, off); }
737
738   // Return true if we need to wait for output sections to be written
739   // before we can apply relocations.  This is true if the object has
740   // any relocations for sections which require special handling, such
741   // as the exception frame section.
742   bool
743   relocs_must_follow_section_writes() const
744   { return this->relocs_must_follow_section_writes_; }
745
746   // Return the object merge map.
747   Object_merge_map*
748   merge_map() const
749   { return this->object_merge_map_; }
750
751   // Set the object merge map.
752   void
753   set_merge_map(Object_merge_map* object_merge_map)
754   {
755     gold_assert(this->object_merge_map_ == NULL);
756     this->object_merge_map_ = object_merge_map;
757   }
758
759   // Record the relocatable reloc info for an input reloc section.
760   void
761   set_relocatable_relocs(unsigned int reloc_shndx, Relocatable_relocs* rr)
762   {
763     gold_assert(reloc_shndx < this->shnum());
764     (*this->map_to_relocatable_relocs_)[reloc_shndx] = rr;
765   }
766
767   // Get the relocatable reloc info for an input reloc section.
768   Relocatable_relocs*
769   relocatable_relocs(unsigned int reloc_shndx)
770   {
771     gold_assert(reloc_shndx < this->shnum());
772     return (*this->map_to_relocatable_relocs_)[reloc_shndx];
773   }
774
775   // Layout sections whose layout was deferred while waiting for
776   // input files from a plugin.
777   void
778   layout_deferred_sections(Layout* layout)
779   { this->do_layout_deferred_sections(layout); }
780
781  protected:
782   // The output section to be used for each input section, indexed by
783   // the input section number.  The output section is NULL if the
784   // input section is to be discarded.
785   typedef std::vector<Output_section*> Output_sections;
786
787   // Read the relocs--implemented by child class.
788   virtual void
789   do_read_relocs(Read_relocs_data*) = 0;
790
791   // Process the relocs--implemented by child class.
792   virtual void
793   do_gc_process_relocs(const General_options&, Symbol_table*, Layout*,
794                  Read_relocs_data*) = 0;
795
796   // Scan the relocs--implemented by child class.
797   virtual void
798   do_scan_relocs(const General_options&, Symbol_table*, Layout*,
799                  Read_relocs_data*) = 0;
800
801   // Return the number of local symbols--implemented by child class.
802   virtual unsigned int
803   do_local_symbol_count() const = 0;
804
805   // Count local symbols--implemented by child class.
806   virtual void
807   do_count_local_symbols(Stringpool_template<char>*,
808                          Stringpool_template<char>*) = 0;
809
810   // Finalize the local symbols.  Set the output symbol table indexes
811   // for the local variables, and set the offset where local symbol
812   // information will be stored.
813   virtual unsigned int
814   do_finalize_local_symbols(unsigned int, off_t, Symbol_table*) = 0;
815
816   // Set the output dynamic symbol table indexes for the local variables.
817   virtual unsigned int
818   do_set_local_dynsym_indexes(unsigned int) = 0;
819
820   // Set the offset where local dynamic symbol information will be stored.
821   virtual unsigned int
822   do_set_local_dynsym_offset(off_t) = 0;
823
824   // Relocate the input sections and write out the local
825   // symbols--implemented by child class.
826   virtual void
827   do_relocate(const General_options& options, const Symbol_table* symtab,
828               const Layout*, Output_file* of) = 0;
829
830   // Get the offset of a section--implemented by child class.
831   virtual uint64_t
832   do_output_section_offset(unsigned int shndx) const = 0;
833
834   // Set the offset of a section--implemented by child class.
835   virtual void
836   do_set_section_offset(unsigned int shndx, uint64_t off) = 0;
837
838   // Layout sections whose layout was deferred while waiting for
839   // input files from a plugin--implemented by child class.
840   virtual void
841   do_layout_deferred_sections(Layout*) = 0;
842
843   // Return the vector mapping input sections to output sections.
844   Output_sections&
845   output_sections()
846   { return this->output_sections_; }
847
848   const Output_sections&
849   output_sections() const
850   { return this->output_sections_; }
851
852   // Set the size of the relocatable relocs array.
853   void
854   size_relocatable_relocs()
855   {
856     this->map_to_relocatable_relocs_ =
857       new std::vector<Relocatable_relocs*>(this->shnum());
858   }
859
860   // Record that we must wait for the output sections to be written
861   // before applying relocations.
862   void
863   set_relocs_must_follow_section_writes()
864   { this->relocs_must_follow_section_writes_ = true; }
865
866  private:
867   // Mapping from input sections to output section.
868   Output_sections output_sections_;
869   // Mapping from input section index to the information recorded for
870   // the relocations.  This is only used for a relocatable link.
871   std::vector<Relocatable_relocs*>* map_to_relocatable_relocs_;
872   // Mappings for merge sections.  This is managed by the code in the
873   // Merge_map class.
874   Object_merge_map* object_merge_map_;
875   // Whether we need to wait for output sections to be written before
876   // we can apply relocations.
877   bool relocs_must_follow_section_writes_;
878   // Used to store the relocs data computed by the Read_relocs pass. 
879   // Used during garbage collection of unused sections.
880   Read_relocs_data* rd_;
881   // Used to store the symbols data computed by the Read_symbols pass.
882   // Again used during garbage collection when laying out referenced
883   // sections.
884   gold::Symbols_data *sd_;
885 };
886
887 // This class is used to handle relocations against a section symbol
888 // in an SHF_MERGE section.  For such a symbol, we need to know the
889 // addend of the relocation before we can determine the final value.
890 // The addend gives us the location in the input section, and we can
891 // determine how it is mapped to the output section.  For a
892 // non-section symbol, we apply the addend to the final value of the
893 // symbol; that is done in finalize_local_symbols, and does not use
894 // this class.
895
896 template<int size>
897 class Merged_symbol_value
898 {
899  public:
900   typedef typename elfcpp::Elf_types<size>::Elf_Addr Value;
901
902   // We use a hash table to map offsets in the input section to output
903   // addresses.
904   typedef Unordered_map<section_offset_type, Value> Output_addresses;
905
906   Merged_symbol_value(Value input_value, Value output_start_address)
907     : input_value_(input_value), output_start_address_(output_start_address),
908       output_addresses_()
909   { }
910
911   // Initialize the hash table.
912   void
913   initialize_input_to_output_map(const Relobj*, unsigned int input_shndx);
914
915   // Release the hash table to save space.
916   void
917   free_input_to_output_map()
918   { this->output_addresses_.clear(); }
919
920   // Get the output value corresponding to an addend.  The object and
921   // input section index are passed in because the caller will have
922   // them; otherwise we could store them here.
923   Value
924   value(const Relobj* object, unsigned int input_shndx, Value addend) const
925   {
926     // This is a relocation against a section symbol.  ADDEND is the
927     // offset in the section.  The result should be the start of some
928     // merge area.  If the object file wants something else, it should
929     // use a regular symbol rather than a section symbol.
930     // Unfortunately, PR 6658 shows a case in which the object file
931     // refers to the section symbol, but uses a negative ADDEND to
932     // compensate for a PC relative reloc.  We can't handle the
933     // general case.  However, we can handle the special case of a
934     // negative addend, by assuming that it refers to the start of the
935     // section.  Of course, that means that we have to guess when
936     // ADDEND is negative.  It is normal to see a 32-bit value here
937     // even when the template parameter size is 64, as 64-bit object
938     // file formats have 32-bit relocations.  We know this is a merge
939     // section, so we know it has to fit into memory.  So we assume
940     // that we won't see a value larger than a large 32-bit unsigned
941     // value.  This will break objects with very very large merge
942     // sections; they probably break in other ways anyhow.
943     Value input_offset = this->input_value_;
944     if (addend < 0xffffff00)
945       {
946         input_offset += addend;
947         addend = 0;
948       }
949     typename Output_addresses::const_iterator p =
950       this->output_addresses_.find(input_offset);
951     if (p != this->output_addresses_.end())
952       return p->second + addend;
953
954     return (this->value_from_output_section(object, input_shndx, input_offset)
955             + addend);
956   }
957
958  private:
959   // Get the output value for an input offset if we couldn't find it
960   // in the hash table.
961   Value
962   value_from_output_section(const Relobj*, unsigned int input_shndx,
963                             Value input_offset) const;
964
965   // The value of the section symbol in the input file.  This is
966   // normally zero, but could in principle be something else.
967   Value input_value_;
968   // The start address of this merged section in the output file.
969   Value output_start_address_;
970   // A hash table which maps offsets in the input section to output
971   // addresses.  This only maps specific offsets, not all offsets.
972   Output_addresses output_addresses_;
973 };
974
975 // This POD class is holds the value of a symbol.  This is used for
976 // local symbols, and for all symbols during relocation processing.
977 // For special sections, such as SHF_MERGE sections, this calls a
978 // function to get the final symbol value.
979
980 template<int size>
981 class Symbol_value
982 {
983  public:
984   typedef typename elfcpp::Elf_types<size>::Elf_Addr Value;
985
986   Symbol_value()
987     : output_symtab_index_(0), output_dynsym_index_(-1U), input_shndx_(0),
988       is_ordinary_shndx_(false), is_section_symbol_(false),
989       is_tls_symbol_(false), has_output_value_(true)
990   { this->u_.value = 0; }
991
992   // Get the value of this symbol.  OBJECT is the object in which this
993   // symbol is defined, and ADDEND is an addend to add to the value.
994   template<bool big_endian>
995   Value
996   value(const Sized_relobj<size, big_endian>* object, Value addend) const
997   {
998     if (this->has_output_value_)
999       return this->u_.value + addend;
1000     else
1001       {
1002         gold_assert(this->is_ordinary_shndx_);
1003         return this->u_.merged_symbol_value->value(object, this->input_shndx_,
1004                                                    addend);
1005       }
1006   }
1007
1008   // Set the value of this symbol in the output symbol table.
1009   void
1010   set_output_value(Value value)
1011   { this->u_.value = value; }
1012
1013   // For a section symbol in a merged section, we need more
1014   // information.
1015   void
1016   set_merged_symbol_value(Merged_symbol_value<size>* msv)
1017   {
1018     gold_assert(this->is_section_symbol_);
1019     this->has_output_value_ = false;
1020     this->u_.merged_symbol_value = msv;
1021   }
1022
1023   // Initialize the input to output map for a section symbol in a
1024   // merged section.  We also initialize the value of a non-section
1025   // symbol in a merged section.
1026   void
1027   initialize_input_to_output_map(const Relobj* object)
1028   {
1029     if (!this->has_output_value_)
1030       {
1031         gold_assert(this->is_section_symbol_ && this->is_ordinary_shndx_);
1032         Merged_symbol_value<size>* msv = this->u_.merged_symbol_value;
1033         msv->initialize_input_to_output_map(object, this->input_shndx_);
1034       }
1035   }
1036
1037   // Free the input to output map for a section symbol in a merged
1038   // section.
1039   void
1040   free_input_to_output_map()
1041   {
1042     if (!this->has_output_value_)
1043       this->u_.merged_symbol_value->free_input_to_output_map();
1044   }
1045
1046   // Set the value of the symbol from the input file.  This is only
1047   // called by count_local_symbols, to communicate the value to
1048   // finalize_local_symbols.
1049   void
1050   set_input_value(Value value)
1051   { this->u_.value = value; }
1052
1053   // Return the input value.  This is only called by
1054   // finalize_local_symbols and (in special cases) relocate_section.
1055   Value
1056   input_value() const
1057   { return this->u_.value; }
1058
1059   // Return whether this symbol should go into the output symbol
1060   // table.
1061   bool
1062   needs_output_symtab_entry() const
1063   { return this->output_symtab_index_ != -1U; }
1064
1065   // Return the index in the output symbol table.
1066   unsigned int
1067   output_symtab_index() const
1068   {
1069     gold_assert(this->output_symtab_index_ != 0);
1070     return this->output_symtab_index_;
1071   }
1072
1073   // Set the index in the output symbol table.
1074   void
1075   set_output_symtab_index(unsigned int i)
1076   {
1077     gold_assert(this->output_symtab_index_ == 0);
1078     this->output_symtab_index_ = i;
1079   }
1080
1081   // Record that this symbol should not go into the output symbol
1082   // table.
1083   void
1084   set_no_output_symtab_entry()
1085   {
1086     gold_assert(this->output_symtab_index_ == 0);
1087     this->output_symtab_index_ = -1U;
1088   }
1089
1090   // Set the index in the output dynamic symbol table.
1091   void
1092   set_needs_output_dynsym_entry()
1093   {
1094     gold_assert(!this->is_section_symbol());
1095     this->output_dynsym_index_ = 0;
1096   }
1097
1098   // Return whether this symbol should go into the output symbol
1099   // table.
1100   bool
1101   needs_output_dynsym_entry() const
1102   {
1103     return this->output_dynsym_index_ != -1U;
1104   }
1105
1106   // Record that this symbol should go into the dynamic symbol table.
1107   void
1108   set_output_dynsym_index(unsigned int i)
1109   {
1110     gold_assert(this->output_dynsym_index_ == 0);
1111     this->output_dynsym_index_ = i;
1112   }
1113
1114   // Return the index in the output dynamic symbol table.
1115   unsigned int
1116   output_dynsym_index() const
1117   {
1118     gold_assert(this->output_dynsym_index_ != 0
1119                 && this->output_dynsym_index_ != -1U);
1120     return this->output_dynsym_index_;
1121   }
1122
1123   // Set the index of the input section in the input file.
1124   void
1125   set_input_shndx(unsigned int i, bool is_ordinary)
1126   {
1127     this->input_shndx_ = i;
1128     // input_shndx_ field is a bitfield, so make sure that the value
1129     // fits.
1130     gold_assert(this->input_shndx_ == i);
1131     this->is_ordinary_shndx_ = is_ordinary;
1132   }
1133
1134   // Return the index of the input section in the input file.
1135   unsigned int
1136   input_shndx(bool* is_ordinary) const
1137   {
1138     *is_ordinary = this->is_ordinary_shndx_;
1139     return this->input_shndx_;
1140   }
1141
1142   // Whether this is a section symbol.
1143   bool
1144   is_section_symbol() const
1145   { return this->is_section_symbol_; }
1146
1147   // Record that this is a section symbol.
1148   void
1149   set_is_section_symbol()
1150   {
1151     gold_assert(!this->needs_output_dynsym_entry());
1152     this->is_section_symbol_ = true;
1153   }
1154
1155   // Record that this is a TLS symbol.
1156   void
1157   set_is_tls_symbol()
1158   { this->is_tls_symbol_ = true; }
1159
1160   // Return TRUE if this is a TLS symbol.
1161   bool
1162   is_tls_symbol() const
1163   { return this->is_tls_symbol_; }
1164
1165  private:
1166   // The index of this local symbol in the output symbol table.  This
1167   // will be -1 if the symbol should not go into the symbol table.
1168   unsigned int output_symtab_index_;
1169   // The index of this local symbol in the dynamic symbol table.  This
1170   // will be -1 if the symbol should not go into the symbol table.
1171   unsigned int output_dynsym_index_;
1172   // The section index in the input file in which this symbol is
1173   // defined.
1174   unsigned int input_shndx_ : 28;
1175   // Whether the section index is an ordinary index, not a special
1176   // value.
1177   bool is_ordinary_shndx_ : 1;
1178   // Whether this is a STT_SECTION symbol.
1179   bool is_section_symbol_ : 1;
1180   // Whether this is a STT_TLS symbol.
1181   bool is_tls_symbol_ : 1;
1182   // Whether this symbol has a value for the output file.  This is
1183   // normally set to true during Layout::finalize, by
1184   // finalize_local_symbols.  It will be false for a section symbol in
1185   // a merge section, as for such symbols we can not determine the
1186   // value to use in a relocation until we see the addend.
1187   bool has_output_value_ : 1;
1188   union
1189   {
1190     // This is used if has_output_value_ is true.  Between
1191     // count_local_symbols and finalize_local_symbols, this is the
1192     // value in the input file.  After finalize_local_symbols, it is
1193     // the value in the output file.
1194     Value value;
1195     // This is used if has_output_value_ is false.  It points to the
1196     // information we need to get the value for a merge section.
1197     Merged_symbol_value<size>* merged_symbol_value;
1198   } u_;
1199 };
1200
1201 // A GOT offset list.  A symbol may have more than one GOT offset
1202 // (e.g., when mixing modules compiled with two different TLS models),
1203 // but will usually have at most one.  GOT_TYPE identifies the type of
1204 // GOT entry; its values are specific to each target.
1205
1206 class Got_offset_list
1207 {
1208  public:
1209   Got_offset_list()
1210     : got_type_(-1U), got_offset_(0), got_next_(NULL)
1211   { }
1212
1213   Got_offset_list(unsigned int got_type, unsigned int got_offset)
1214     : got_type_(got_type), got_offset_(got_offset), got_next_(NULL)
1215   { }
1216
1217   ~Got_offset_list()
1218   { 
1219     if (this->got_next_ != NULL)
1220       {
1221         delete this->got_next_;
1222         this->got_next_ = NULL;
1223       }
1224   }
1225
1226   // Initialize the fields to their default values.
1227   void
1228   init()
1229   {
1230     this->got_type_ = -1U;
1231     this->got_offset_ = 0;
1232     this->got_next_ = NULL;
1233   }
1234
1235   // Set the offset for the GOT entry of type GOT_TYPE.
1236   void
1237   set_offset(unsigned int got_type, unsigned int got_offset)
1238   {
1239     if (this->got_type_ == -1U)
1240       {
1241         this->got_type_ = got_type;
1242         this->got_offset_ = got_offset;
1243       }
1244     else
1245       {
1246         for (Got_offset_list* g = this; g != NULL; g = g->got_next_)
1247           {
1248             if (g->got_type_ == got_type)
1249               {
1250                 g->got_offset_ = got_offset;
1251                 return;
1252               }
1253           }
1254         Got_offset_list* g = new Got_offset_list(got_type, got_offset);
1255         g->got_next_ = this->got_next_;
1256         this->got_next_ = g;
1257       }
1258   }
1259
1260   // Return the offset for a GOT entry of type GOT_TYPE.
1261   unsigned int
1262   get_offset(unsigned int got_type) const
1263   {
1264     for (const Got_offset_list* g = this; g != NULL; g = g->got_next_)
1265       {
1266         if (g->got_type_ == got_type)
1267           return g->got_offset_;
1268       }
1269     return -1U;
1270   }
1271
1272  private:
1273   unsigned int got_type_;
1274   unsigned int got_offset_;
1275   Got_offset_list* got_next_;
1276 };
1277
1278 // This type is used to modify relocations for -fsplit-stack.  It is
1279 // indexed by relocation index, and means that the relocation at that
1280 // index should use the symbol from the vector, rather than the one
1281 // indicated by the relocation.
1282
1283 class Reloc_symbol_changes
1284 {
1285  public:
1286   Reloc_symbol_changes(size_t count)
1287     : vec_(count, NULL)
1288   { }
1289
1290   void
1291   set(size_t i, Symbol* sym)
1292   { this->vec_[i] = sym; }
1293
1294   const Symbol*
1295   operator[](size_t i) const
1296   { return this->vec_[i]; }
1297
1298  private:
1299   std::vector<Symbol*> vec_;
1300 };
1301
1302 // A regular object file.  This is size and endian specific.
1303
1304 template<int size, bool big_endian>
1305 class Sized_relobj : public Relobj
1306 {
1307  public:
1308   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
1309   typedef std::vector<Symbol*> Symbols;
1310   typedef std::vector<Symbol_value<size> > Local_values;
1311
1312   static const Address invalid_address = static_cast<Address>(0) - 1;
1313
1314   Sized_relobj(const std::string& name, Input_file* input_file, off_t offset,
1315                const typename elfcpp::Ehdr<size, big_endian>&);
1316
1317   ~Sized_relobj();
1318
1319   // Checks if the offset of input section SHNDX within its output
1320   // section is invalid. 
1321   bool
1322   is_output_section_offset_invalid(unsigned int shndx) const
1323   { return this->get_output_section_offset(shndx) == invalid_address; }
1324
1325   // Set up the object file based on TARGET.
1326   void
1327   setup()
1328   { this->do_setup(); }
1329
1330   // Return the number of symbols.  This is only valid after
1331   // Object::add_symbols has been called.
1332   unsigned int
1333   symbol_count() const
1334   { return this->local_symbol_count_ + this->symbols_.size(); }
1335
1336   // If SYM is the index of a global symbol in the object file's
1337   // symbol table, return the Symbol object.  Otherwise, return NULL.
1338   Symbol*
1339   global_symbol(unsigned int sym) const
1340   {
1341     if (sym >= this->local_symbol_count_)
1342       {
1343         gold_assert(sym - this->local_symbol_count_ < this->symbols_.size());
1344         return this->symbols_[sym - this->local_symbol_count_];
1345       }
1346     return NULL;
1347   }
1348
1349   // Return the section index of symbol SYM.  Set *VALUE to its value
1350   // in the object file.  Set *IS_ORDINARY if this is an ordinary
1351   // section index, not a special code between SHN_LORESERVE and
1352   // SHN_HIRESERVE.  Note that for a symbol which is not defined in
1353   // this object file, this will set *VALUE to 0 and return SHN_UNDEF;
1354   // it will not return the final value of the symbol in the link.
1355   unsigned int
1356   symbol_section_and_value(unsigned int sym, Address* value, bool* is_ordinary);
1357
1358   // Return a pointer to the Symbol_value structure which holds the
1359   // value of a local symbol.
1360   const Symbol_value<size>*
1361   local_symbol(unsigned int sym) const
1362   {
1363     gold_assert(sym < this->local_values_.size());
1364     return &this->local_values_[sym];
1365   }
1366
1367   // Return the index of local symbol SYM in the ordinary symbol
1368   // table.  A value of -1U means that the symbol is not being output.
1369   unsigned int
1370   symtab_index(unsigned int sym) const
1371   {
1372     gold_assert(sym < this->local_values_.size());
1373     return this->local_values_[sym].output_symtab_index();
1374   }
1375
1376   // Return the index of local symbol SYM in the dynamic symbol
1377   // table.  A value of -1U means that the symbol is not being output.
1378   unsigned int
1379   dynsym_index(unsigned int sym) const
1380   {
1381     gold_assert(sym < this->local_values_.size());
1382     return this->local_values_[sym].output_dynsym_index();
1383   }
1384
1385   // Return the input section index of local symbol SYM.
1386   unsigned int
1387   local_symbol_input_shndx(unsigned int sym, bool* is_ordinary) const
1388   {
1389     gold_assert(sym < this->local_values_.size());
1390     return this->local_values_[sym].input_shndx(is_ordinary);
1391   }
1392
1393   // Record that local symbol SYM needs a dynamic symbol entry.
1394   void
1395   set_needs_output_dynsym_entry(unsigned int sym)
1396   {
1397     gold_assert(sym < this->local_values_.size());
1398     this->local_values_[sym].set_needs_output_dynsym_entry();
1399   }
1400
1401   // Return whether the local symbol SYMNDX has a GOT offset.
1402   // For TLS symbols, the GOT entry will hold its tp-relative offset.
1403   bool
1404   local_has_got_offset(unsigned int symndx, unsigned int got_type) const
1405   {
1406     Local_got_offsets::const_iterator p =
1407         this->local_got_offsets_.find(symndx);
1408     return (p != this->local_got_offsets_.end()
1409             && p->second->get_offset(got_type) != -1U);
1410   }
1411
1412   // Return the GOT offset of the local symbol SYMNDX.
1413   unsigned int
1414   local_got_offset(unsigned int symndx, unsigned int got_type) const
1415   {
1416     Local_got_offsets::const_iterator p =
1417         this->local_got_offsets_.find(symndx);
1418     gold_assert(p != this->local_got_offsets_.end());
1419     unsigned int off = p->second->get_offset(got_type);
1420     gold_assert(off != -1U);
1421     return off;
1422   }
1423
1424   // Set the GOT offset of the local symbol SYMNDX to GOT_OFFSET.
1425   void
1426   set_local_got_offset(unsigned int symndx, unsigned int got_type,
1427                        unsigned int got_offset)
1428   {
1429     Local_got_offsets::const_iterator p =
1430         this->local_got_offsets_.find(symndx);
1431     if (p != this->local_got_offsets_.end())
1432       p->second->set_offset(got_type, got_offset);
1433     else
1434       {
1435         Got_offset_list* g = new Got_offset_list(got_type, got_offset);
1436         std::pair<Local_got_offsets::iterator, bool> ins =
1437             this->local_got_offsets_.insert(std::make_pair(symndx, g));
1438         gold_assert(ins.second);
1439       }
1440   }
1441
1442   // Get the offset of input section SHNDX within its output section.
1443   // This is -1 if the input section requires a special mapping, such
1444   // as a merge section.  The output section can be found in the
1445   // output_sections_ field of the parent class Relobj.
1446   Address
1447   get_output_section_offset(unsigned int shndx) const
1448   {
1449     gold_assert(shndx < this->section_offsets_.size());
1450     return this->section_offsets_[shndx];
1451   }
1452
1453   // Return the name of the symbol that spans the given offset in the
1454   // specified section in this object.  This is used only for error
1455   // messages and is not particularly efficient.
1456   bool
1457   get_symbol_location_info(unsigned int shndx, off_t offset,
1458                            Symbol_location_info* info);
1459
1460   // Look for a kept section corresponding to the given discarded section,
1461   // and return its output address.  This is used only for relocations in
1462   // debugging sections.
1463   Address
1464   map_to_kept_section(unsigned int shndx, bool* found) const;
1465
1466   // Make section offset invalid.  This is needed for relaxation.
1467   void
1468   invalidate_section_offset(unsigned int shndx)
1469   { this->do_invalidate_section_offset(shndx); }
1470
1471  protected:
1472   // Set up.
1473   virtual void
1474   do_setup();
1475
1476   // Read the symbols.
1477   void
1478   do_read_symbols(Read_symbols_data*);
1479
1480   // Return the number of local symbols.
1481   unsigned int
1482   do_local_symbol_count() const
1483   { return this->local_symbol_count_; }
1484
1485   // Lay out the input sections.
1486   void
1487   do_layout(Symbol_table*, Layout*, Read_symbols_data*);
1488
1489   // Layout sections whose layout was deferred while waiting for
1490   // input files from a plugin.
1491   void
1492   do_layout_deferred_sections(Layout*);
1493
1494   // Add the symbols to the symbol table.
1495   void
1496   do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
1497
1498   // Read the relocs.
1499   void
1500   do_read_relocs(Read_relocs_data*);
1501
1502   // Process the relocs to find list of referenced sections. Used only
1503   // during garbage collection.
1504   void
1505   do_gc_process_relocs(const General_options&, Symbol_table*, Layout*,
1506                        Read_relocs_data*);
1507
1508   // Scan the relocs and adjust the symbol table.
1509   void
1510   do_scan_relocs(const General_options&, Symbol_table*, Layout*,
1511                  Read_relocs_data*);
1512
1513   // Count the local symbols.
1514   void
1515   do_count_local_symbols(Stringpool_template<char>*,
1516                             Stringpool_template<char>*);
1517
1518   // Finalize the local symbols.
1519   unsigned int
1520   do_finalize_local_symbols(unsigned int, off_t, Symbol_table*);
1521
1522   // Set the offset where local dynamic symbol information will be stored.
1523   unsigned int
1524   do_set_local_dynsym_indexes(unsigned int);
1525
1526   // Set the offset where local dynamic symbol information will be stored.
1527   unsigned int
1528   do_set_local_dynsym_offset(off_t);
1529
1530   // Relocate the input sections and write out the local symbols.
1531   void
1532   do_relocate(const General_options& options, const Symbol_table* symtab,
1533               const Layout*, Output_file* of);
1534
1535   // Get the size of a section.
1536   uint64_t
1537   do_section_size(unsigned int shndx)
1538   { return this->elf_file_.section_size(shndx); }
1539
1540   // Get the name of a section.
1541   std::string
1542   do_section_name(unsigned int shndx)
1543   { return this->elf_file_.section_name(shndx); }
1544
1545   // Return the location of the contents of a section.
1546   Object::Location
1547   do_section_contents(unsigned int shndx)
1548   { return this->elf_file_.section_contents(shndx); }
1549
1550   // Return section flags.
1551   uint64_t
1552   do_section_flags(unsigned int shndx);
1553
1554   // Return section entsize.
1555   uint64_t
1556   do_section_entsize(unsigned int shndx);
1557
1558   // Return section address.
1559   uint64_t
1560   do_section_address(unsigned int shndx)
1561   { return this->elf_file_.section_addr(shndx); }
1562
1563   // Return section type.
1564   unsigned int
1565   do_section_type(unsigned int shndx)
1566   { return this->elf_file_.section_type(shndx); }
1567
1568   // Return the section link field.
1569   unsigned int
1570   do_section_link(unsigned int shndx)
1571   { return this->elf_file_.section_link(shndx); }
1572
1573   // Return the section info field.
1574   unsigned int
1575   do_section_info(unsigned int shndx)
1576   { return this->elf_file_.section_info(shndx); }
1577
1578   // Return the section alignment.
1579   uint64_t
1580   do_section_addralign(unsigned int shndx)
1581   { return this->elf_file_.section_addralign(shndx); }
1582
1583   // Return the Xindex structure to use.
1584   Xindex*
1585   do_initialize_xindex();
1586
1587   // Get symbol counts.
1588   void
1589   do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
1590
1591   // Get the offset of a section.
1592   uint64_t
1593   do_output_section_offset(unsigned int shndx) const
1594   {
1595     Address off = this->get_output_section_offset(shndx);
1596     if (off == invalid_address)
1597       return -1ULL;
1598     return off;
1599   }
1600
1601   // Set the offset of a section.
1602   void
1603   do_set_section_offset(unsigned int shndx, uint64_t off)
1604   {
1605     gold_assert(shndx < this->section_offsets_.size());
1606     this->section_offsets_[shndx] = convert_types<Address, uint64_t>(off);
1607   }
1608
1609   // Set the offset of a section to invalid_address.
1610   virtual void
1611   do_invalidate_section_offset(unsigned int shndx)
1612   {
1613     gold_assert(shndx < this->section_offsets_.size());
1614     this->section_offsets_[shndx] = invalid_address;
1615   }
1616
1617   // Adjust a section index if necessary.
1618   unsigned int
1619   adjust_shndx(unsigned int shndx)
1620   {
1621     if (shndx >= elfcpp::SHN_LORESERVE)
1622       shndx += this->elf_file_.large_shndx_offset();
1623     return shndx;
1624   }
1625
1626   // Initialize input to output maps for section symbols in merged
1627   // sections.
1628   void
1629   initialize_input_to_output_maps();
1630
1631   // Free the input to output maps for section symbols in merged
1632   // sections.
1633   void
1634   free_input_to_output_maps();
1635
1636   // Return symbol table section index.
1637   unsigned int
1638   symtab_shndx() const
1639   { return this->symtab_shndx_; }
1640
1641   // Allow a child class to access the ELF file.
1642   elfcpp::Elf_file<size, big_endian, Object>*
1643   elf_file()
1644   { return &this->elf_file_; }
1645   
1646   // Allow a child class to access the local values.
1647   Local_values*
1648   local_values()
1649   { return &this->local_values_; }
1650
1651  private:
1652   // For convenience.
1653   typedef Sized_relobj<size, big_endian> This;
1654   static const int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
1655   static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
1656   static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1657   typedef elfcpp::Shdr<size, big_endian> Shdr;
1658
1659   // To keep track of discarded comdat sections, we need to map a member
1660   // section index to the object and section index of the corresponding
1661   // kept section.
1662   struct Kept_comdat_section
1663   {
1664     Kept_comdat_section(Relobj* a_object, unsigned int a_shndx)
1665       : object(a_object), shndx(a_shndx)
1666     { }
1667     Relobj* object;
1668     unsigned int shndx;
1669   };
1670   typedef std::map<unsigned int, Kept_comdat_section>
1671       Kept_comdat_section_table;
1672
1673   // Find the SHT_SYMTAB section, given the section headers.
1674   void
1675   find_symtab(const unsigned char* pshdrs);
1676
1677   // Return whether SHDR has the right flags for a GNU style exception
1678   // frame section.
1679   bool
1680   check_eh_frame_flags(const elfcpp::Shdr<size, big_endian>* shdr) const;
1681
1682   // Return whether there is a section named .eh_frame which might be
1683   // a GNU style exception frame section.
1684   bool
1685   find_eh_frame(const unsigned char* pshdrs, const char* names,
1686                 section_size_type names_size) const;
1687
1688   // Whether to include a section group in the link.
1689   bool
1690   include_section_group(Symbol_table*, Layout*, unsigned int, const char*,
1691                         const unsigned char*, const char *, section_size_type,
1692                         std::vector<bool>*);
1693
1694   // Whether to include a linkonce section in the link.
1695   bool
1696   include_linkonce_section(Layout*, unsigned int, const char*,
1697                            const elfcpp::Shdr<size, big_endian>&);
1698
1699   // Layout an input section.
1700   void
1701   layout_section(Layout* layout, unsigned int shndx, const char* name,
1702                  typename This::Shdr& shdr, unsigned int reloc_shndx,
1703                  unsigned int reloc_type);
1704
1705   // Views and sizes when relocating.
1706   struct View_size
1707   {
1708     unsigned char* view;
1709     typename elfcpp::Elf_types<size>::Elf_Addr address;
1710     off_t offset;
1711     section_size_type view_size;
1712     bool is_input_output_view;
1713     bool is_postprocessing_view;
1714   };
1715
1716   typedef std::vector<View_size> Views;
1717
1718   // Write section data to the output file.  Record the views and
1719   // sizes in VIEWS for use when relocating.
1720   void
1721   write_sections(const unsigned char* pshdrs, Output_file*, Views*);
1722
1723   // Relocate the sections in the output file.
1724   void
1725   relocate_sections(const General_options& options, const Symbol_table*,
1726                     const Layout*, const unsigned char* pshdrs, Views*);
1727
1728   // Scan the input relocations for --emit-relocs.
1729   void
1730   emit_relocs_scan(const General_options&, Symbol_table*, Layout*,
1731                    const unsigned char* plocal_syms,
1732                    const Read_relocs_data::Relocs_list::iterator&);
1733
1734   // Scan the input relocations for --emit-relocs, templatized on the
1735   // type of the relocation section.
1736   template<int sh_type>
1737   void
1738   emit_relocs_scan_reltype(const General_options&, Symbol_table*, Layout*,
1739                            const unsigned char* plocal_syms,
1740                            const Read_relocs_data::Relocs_list::iterator&,
1741                            Relocatable_relocs*);
1742
1743   // Emit the relocs for --emit-relocs.
1744   void
1745   emit_relocs(const Relocate_info<size, big_endian>*, unsigned int,
1746               unsigned int sh_type, const unsigned char* prelocs,
1747               size_t reloc_count, Output_section*, Address output_offset,
1748               unsigned char* view, Address address,
1749               section_size_type view_size,
1750               unsigned char* reloc_view, section_size_type reloc_view_size);
1751
1752   // Emit the relocs for --emit-relocs, templatized on the type of the
1753   // relocation section.
1754   template<int sh_type>
1755   void
1756   emit_relocs_reltype(const Relocate_info<size, big_endian>*, unsigned int,
1757                       const unsigned char* prelocs, size_t reloc_count,
1758                       Output_section*, Address output_offset,
1759                       unsigned char* view, Address address,
1760                       section_size_type view_size,
1761                       unsigned char* reloc_view,
1762                       section_size_type reloc_view_size);
1763
1764   // A type shared by split_stack_adjust_reltype and find_functions.
1765   typedef std::map<section_offset_type, section_size_type> Function_offsets;
1766
1767   // Check for -fsplit-stack routines calling non-split-stack routines.
1768   void
1769   split_stack_adjust(const Symbol_table*, const unsigned char* pshdrs,
1770                      unsigned int sh_type, unsigned int shndx,
1771                      const unsigned char* prelocs, size_t reloc_count,
1772                      unsigned char* view, section_size_type view_size,
1773                      Reloc_symbol_changes** reloc_map);
1774
1775   template<int sh_type>
1776   void
1777   split_stack_adjust_reltype(const Symbol_table*, const unsigned char* pshdrs,
1778                              unsigned int shndx, const unsigned char* prelocs,
1779                              size_t reloc_count, unsigned char* view,
1780                              section_size_type view_size,
1781                              Reloc_symbol_changes** reloc_map);
1782
1783   // Find all functions in a section.
1784   void
1785   find_functions(const unsigned char* pshdrs, unsigned int shndx,
1786                  Function_offsets*);
1787
1788   // Write out the local symbols.
1789   void
1790   write_local_symbols(Output_file*,
1791                       const Stringpool_template<char>*,
1792                       const Stringpool_template<char>*,
1793                       Output_symtab_xindex*,
1794                       Output_symtab_xindex*);
1795
1796   // Clear the local symbol information.
1797   void
1798   clear_local_symbols()
1799   {
1800     this->local_values_.clear();
1801     this->local_got_offsets_.clear();
1802   }
1803
1804   // Record a mapping from discarded section SHNDX to the corresponding
1805   // kept section.
1806   void
1807   set_kept_comdat_section(unsigned int shndx, Relobj* kept_object,
1808                           unsigned int kept_shndx)
1809   {
1810     Kept_comdat_section kept(kept_object, kept_shndx);
1811     this->kept_comdat_sections_.insert(std::make_pair(shndx, kept));
1812   }
1813
1814   // Find the kept section corresponding to the discarded section
1815   // SHNDX.  Return true if found.
1816   bool
1817   get_kept_comdat_section(unsigned int shndx, Relobj** kept_object,
1818                           unsigned int* kept_shndx) const
1819   {
1820     typename Kept_comdat_section_table::const_iterator p =
1821       this->kept_comdat_sections_.find(shndx);
1822     if (p == this->kept_comdat_sections_.end())
1823       return false;
1824     *kept_object = p->second.object;
1825     *kept_shndx = p->second.shndx;
1826     return true;
1827   }
1828
1829   // The GOT offsets of local symbols. This map also stores GOT offsets
1830   // for tp-relative offsets for TLS symbols.
1831   typedef Unordered_map<unsigned int, Got_offset_list*> Local_got_offsets;
1832
1833   // The TLS GOT offsets of local symbols. The map stores the offsets
1834   // for either a single GOT entry that holds the module index of a TLS
1835   // symbol, or a pair of GOT entries containing the module index and
1836   // dtv-relative offset.
1837   struct Tls_got_entry
1838   {
1839     Tls_got_entry(int got_offset, bool have_pair)
1840       : got_offset_(got_offset),
1841         have_pair_(have_pair)
1842     { }
1843     int got_offset_;
1844     bool have_pair_;
1845   };
1846   typedef Unordered_map<unsigned int, Tls_got_entry> Local_tls_got_offsets;
1847
1848   // Saved information for sections whose layout was deferred.
1849   struct Deferred_layout
1850   {
1851     static const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
1852     Deferred_layout(unsigned int shndx, const char* name,
1853                     const unsigned char* pshdr,
1854                     unsigned int reloc_shndx, unsigned int reloc_type)
1855       : shndx_(shndx), name_(name), reloc_shndx_(reloc_shndx),
1856         reloc_type_(reloc_type)
1857     {
1858       memcpy(this->shdr_data_, pshdr, shdr_size);
1859     }
1860     unsigned int shndx_;
1861     std::string name_;
1862     unsigned int reloc_shndx_;
1863     unsigned int reloc_type_;
1864     unsigned char shdr_data_[shdr_size];
1865   };
1866
1867   // General access to the ELF file.
1868   elfcpp::Elf_file<size, big_endian, Object> elf_file_;
1869   // Index of SHT_SYMTAB section.
1870   unsigned int symtab_shndx_;
1871   // The number of local symbols.
1872   unsigned int local_symbol_count_;
1873   // The number of local symbols which go into the output file.
1874   unsigned int output_local_symbol_count_;
1875   // The number of local symbols which go into the output file's dynamic
1876   // symbol table.
1877   unsigned int output_local_dynsym_count_;
1878   // The entries in the symbol table for the external symbols.
1879   Symbols symbols_;
1880   // Number of symbols defined in object file itself.
1881   size_t defined_count_;
1882   // File offset for local symbols.
1883   off_t local_symbol_offset_;
1884   // File offset for local dynamic symbols.
1885   off_t local_dynsym_offset_;
1886   // Values of local symbols.
1887   Local_values local_values_;
1888   // GOT offsets for local non-TLS symbols, and tp-relative offsets
1889   // for TLS symbols, indexed by symbol number.
1890   Local_got_offsets local_got_offsets_;
1891   // For each input section, the offset of the input section in its
1892   // output section.  This is INVALID_ADDRESS if the input section requires a
1893   // special mapping.
1894   std::vector<Address> section_offsets_;
1895   // Table mapping discarded comdat sections to corresponding kept sections.
1896   Kept_comdat_section_table kept_comdat_sections_;
1897   // Whether this object has a GNU style .eh_frame section.
1898   bool has_eh_frame_;
1899   // If this object has a GNU style .eh_frame section that is discarded in
1900   // output, record the index here.  Otherwise it is -1U.
1901   unsigned int discarded_eh_frame_shndx_;
1902   // The list of sections whose layout was deferred.
1903   std::vector<Deferred_layout> deferred_layout_;
1904 };
1905
1906 // A class to manage the list of all objects.
1907
1908 class Input_objects
1909 {
1910  public:
1911   Input_objects()
1912     : relobj_list_(), dynobj_list_(), sonames_(), cref_(NULL)
1913   { }
1914
1915   // The type of the list of input relocateable objects.
1916   typedef std::vector<Relobj*> Relobj_list;
1917   typedef Relobj_list::const_iterator Relobj_iterator;
1918
1919   // The type of the list of input dynamic objects.
1920   typedef std::vector<Dynobj*> Dynobj_list;
1921   typedef Dynobj_list::const_iterator Dynobj_iterator;
1922
1923   // Add an object to the list.  Return true if all is well, or false
1924   // if this object should be ignored.
1925   bool
1926   add_object(Object*);
1927
1928   // Start processing an archive.
1929   void
1930   archive_start(Archive*);
1931
1932   // Stop processing an archive.
1933   void
1934   archive_stop(Archive*);
1935
1936   // For each dynamic object, check whether we've seen all of its
1937   // explicit dependencies.
1938   void
1939   check_dynamic_dependencies() const;
1940
1941   // Return whether an object was found in the system library
1942   // directory.
1943   bool
1944   found_in_system_library_directory(const Object*) const;
1945
1946   // Print symbol counts.
1947   void
1948   print_symbol_counts(const Symbol_table*) const;
1949
1950   // Iterate over all regular objects.
1951
1952   Relobj_iterator
1953   relobj_begin() const
1954   { return this->relobj_list_.begin(); }
1955
1956   Relobj_iterator
1957   relobj_end() const
1958   { return this->relobj_list_.end(); }
1959
1960   // Iterate over all dynamic objects.
1961
1962   Dynobj_iterator
1963   dynobj_begin() const
1964   { return this->dynobj_list_.begin(); }
1965
1966   Dynobj_iterator
1967   dynobj_end() const
1968   { return this->dynobj_list_.end(); }
1969
1970   // Return whether we have seen any dynamic objects.
1971   bool
1972   any_dynamic() const
1973   { return !this->dynobj_list_.empty(); }
1974
1975   // Return the number of input objects.
1976   int
1977   number_of_input_objects() const
1978   { return this->relobj_list_.size() + this->dynobj_list_.size(); }
1979
1980  private:
1981   Input_objects(const Input_objects&);
1982   Input_objects& operator=(const Input_objects&);
1983
1984   // The list of ordinary objects included in the link.
1985   Relobj_list relobj_list_;
1986   // The list of dynamic objects included in the link.
1987   Dynobj_list dynobj_list_;
1988   // SONAMEs that we have seen.
1989   Unordered_set<std::string> sonames_;
1990   // Manage cross-references if requested.
1991   Cref* cref_;
1992 };
1993
1994 // Some of the information we pass to the relocation routines.  We
1995 // group this together to avoid passing a dozen different arguments.
1996
1997 template<int size, bool big_endian>
1998 struct Relocate_info
1999 {
2000   // Command line options.
2001   const General_options* options;
2002   // Symbol table.
2003   const Symbol_table* symtab;
2004   // Layout.
2005   const Layout* layout;
2006   // Object being relocated.
2007   Sized_relobj<size, big_endian>* object;
2008   // Section index of relocation section.
2009   unsigned int reloc_shndx;
2010   // Section header of relocation section.
2011   const unsigned char* reloc_shdr;
2012   // Section index of section being relocated.
2013   unsigned int data_shndx;
2014   // Section header of data section.
2015   const unsigned char* data_shdr;
2016
2017   // Return a string showing the location of a relocation.  This is
2018   // only used for error messages.
2019   std::string
2020   location(size_t relnum, off_t reloffset) const;
2021 };
2022
2023 // Return whether INPUT_FILE contains an ELF object start at file
2024 // offset OFFSET.  This sets *START to point to a view of the start of
2025 // the file.  It sets *READ_SIZE to the number of bytes in the view.
2026
2027 extern bool
2028 is_elf_object(Input_file* input_file, off_t offset,
2029               const unsigned char** start, int *read_size);
2030
2031 // Return an Object appropriate for the input file.  P is BYTES long,
2032 // and holds the ELF header.  If PUNCONFIGURED is not NULL, then if
2033 // this sees an object the linker is not configured to support, it
2034 // sets *PUNCONFIGURED to true and returns NULL without giving an
2035 // error message.
2036
2037 extern Object*
2038 make_elf_object(const std::string& name, Input_file*,
2039                 off_t offset, const unsigned char* p,
2040                 section_offset_type bytes, bool* punconfigured);
2041
2042 } // end namespace gold
2043
2044 #endif // !defined(GOLD_OBJECT_H)