Automatic date update in version.in
[external/binutils.git] / gold / output.h
1 // output.h -- manage the output file for gold   -*- C++ -*-
2
3 // Copyright (C) 2006-2018 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_OUTPUT_H
24 #define GOLD_OUTPUT_H
25
26 #include <algorithm>
27 #include <list>
28 #include <vector>
29
30 #include "elfcpp.h"
31 #include "mapfile.h"
32 #include "layout.h"
33 #include "reloc-types.h"
34
35 namespace gold
36 {
37
38 class General_options;
39 class Object;
40 class Symbol;
41 class Output_merge_base;
42 class Output_section;
43 class Relocatable_relocs;
44 class Target;
45 template<int size, bool big_endian>
46 class Sized_target;
47 template<int size, bool big_endian>
48 class Sized_relobj;
49 template<int size, bool big_endian>
50 class Sized_relobj_file;
51
52 // This class represents the output file.
53
54 class Output_file
55 {
56  public:
57   Output_file(const char* name);
58
59   // Indicate that this is a temporary file which should not be
60   // output.
61   void
62   set_is_temporary()
63   { this->is_temporary_ = true; }
64
65   // Try to open an existing file. Returns false if the file doesn't
66   // exist, has a size of 0 or can't be mmaped.  This method is
67   // thread-unsafe.  If BASE_NAME is not NULL, use the contents of
68   // that file as the base for incremental linking.
69   bool
70   open_base_file(const char* base_name, bool writable);
71
72   // Open the output file.  FILE_SIZE is the final size of the file.
73   // If the file already exists, it is deleted/truncated.  This method
74   // is thread-unsafe.
75   void
76   open(off_t file_size);
77
78   // Resize the output file.  This method is thread-unsafe.
79   void
80   resize(off_t file_size);
81
82   // Close the output file (flushing all buffered data) and make sure
83   // there are no errors.  This method is thread-unsafe.
84   void
85   close();
86
87   // Return the size of this file.
88   off_t
89   filesize()
90   { return this->file_size_; }
91
92   // Return the name of this file.
93   const char*
94   filename()
95   { return this->name_; }
96
97   // We currently always use mmap which makes the view handling quite
98   // simple.  In the future we may support other approaches.
99
100   // Write data to the output file.
101   void
102   write(off_t offset, const void* data, size_t len)
103   { memcpy(this->base_ + offset, data, len); }
104
105   // Get a buffer to use to write to the file, given the offset into
106   // the file and the size.
107   unsigned char*
108   get_output_view(off_t start, size_t size)
109   {
110     gold_assert(start >= 0
111                 && start + static_cast<off_t>(size) <= this->file_size_);
112     return this->base_ + start;
113   }
114
115   // VIEW must have been returned by get_output_view.  Write the
116   // buffer to the file, passing in the offset and the size.
117   void
118   write_output_view(off_t, size_t, unsigned char*)
119   { }
120
121   // Get a read/write buffer.  This is used when we want to write part
122   // of the file, read it in, and write it again.
123   unsigned char*
124   get_input_output_view(off_t start, size_t size)
125   { return this->get_output_view(start, size); }
126
127   // Write a read/write buffer back to the file.
128   void
129   write_input_output_view(off_t, size_t, unsigned char*)
130   { }
131
132   // Get a read buffer.  This is used when we just want to read part
133   // of the file back it in.
134   const unsigned char*
135   get_input_view(off_t start, size_t size)
136   { return this->get_output_view(start, size); }
137
138   // Release a read bfufer.
139   void
140   free_input_view(off_t, size_t, const unsigned char*)
141   { }
142
143  private:
144   // Map the file into memory or, if that fails, allocate anonymous
145   // memory.
146   void
147   map();
148
149   // Allocate anonymous memory for the file.
150   bool
151   map_anonymous();
152
153   // Map the file into memory.
154   bool
155   map_no_anonymous(bool);
156
157   // Unmap the file from memory (and flush to disk buffers).
158   void
159   unmap();
160
161   // File name.
162   const char* name_;
163   // File descriptor.
164   int o_;
165   // File size.
166   off_t file_size_;
167   // Base of file mapped into memory.
168   unsigned char* base_;
169   // True iff base_ points to a memory buffer rather than an output file.
170   bool map_is_anonymous_;
171   // True if base_ was allocated using new rather than mmap.
172   bool map_is_allocated_;
173   // True if this is a temporary file which should not be output.
174   bool is_temporary_;
175 };
176
177 // An abtract class for data which has to go into the output file.
178
179 class Output_data
180 {
181  public:
182   explicit Output_data()
183     : address_(0), data_size_(0), offset_(-1),
184       is_address_valid_(false), is_data_size_valid_(false),
185       is_offset_valid_(false), is_data_size_fixed_(false),
186       has_dynamic_reloc_(false)
187   { }
188
189   virtual
190   ~Output_data();
191
192   // Return the address.  For allocated sections, this is only valid
193   // after Layout::finalize is finished.
194   uint64_t
195   address() const
196   {
197     gold_assert(this->is_address_valid_);
198     return this->address_;
199   }
200
201   // Return the size of the data.  For allocated sections, this must
202   // be valid after Layout::finalize calls set_address, but need not
203   // be valid before then.
204   off_t
205   data_size() const
206   {
207     gold_assert(this->is_data_size_valid_);
208     return this->data_size_;
209   }
210
211   // Get the current data size.
212   off_t
213   current_data_size() const
214   { return this->current_data_size_for_child(); }
215
216   // Return true if data size is fixed.
217   bool
218   is_data_size_fixed() const
219   { return this->is_data_size_fixed_; }
220
221   // Return the file offset.  This is only valid after
222   // Layout::finalize is finished.  For some non-allocated sections,
223   // it may not be valid until near the end of the link.
224   off_t
225   offset() const
226   {
227     gold_assert(this->is_offset_valid_);
228     return this->offset_;
229   }
230
231   // Reset the address, file offset and data size.  This essentially
232   // disables the sanity testing about duplicate and unknown settings.
233   void
234   reset_address_and_file_offset()
235   {
236     this->is_address_valid_ = false;
237     this->is_offset_valid_ = false;
238     if (!this->is_data_size_fixed_)
239       this->is_data_size_valid_ = false;
240     this->do_reset_address_and_file_offset();
241   }
242
243   // As above, but just for data size.
244   void
245   reset_data_size()
246   {
247     if (!this->is_data_size_fixed_)
248       this->is_data_size_valid_ = false;
249   }
250
251   // Return true if address and file offset already have reset values. In
252   // other words, calling reset_address_and_file_offset will not change them.
253   bool
254   address_and_file_offset_have_reset_values() const
255   { return this->do_address_and_file_offset_have_reset_values(); }
256
257   // Return the required alignment.
258   uint64_t
259   addralign() const
260   { return this->do_addralign(); }
261
262   // Return whether this has a load address.
263   bool
264   has_load_address() const
265   { return this->do_has_load_address(); }
266
267   // Return the load address.
268   uint64_t
269   load_address() const
270   { return this->do_load_address(); }
271
272   // Return whether this is an Output_section.
273   bool
274   is_section() const
275   { return this->do_is_section(); }
276
277   // Return whether this is an Output_section of the specified type.
278   bool
279   is_section_type(elfcpp::Elf_Word stt) const
280   { return this->do_is_section_type(stt); }
281
282   // Return whether this is an Output_section with the specified flag
283   // set.
284   bool
285   is_section_flag_set(elfcpp::Elf_Xword shf) const
286   { return this->do_is_section_flag_set(shf); }
287
288   // Return the output section that this goes in, if there is one.
289   Output_section*
290   output_section()
291   { return this->do_output_section(); }
292
293   const Output_section*
294   output_section() const
295   { return this->do_output_section(); }
296
297   // Return the output section index, if there is an output section.
298   unsigned int
299   out_shndx() const
300   { return this->do_out_shndx(); }
301
302   // Set the output section index, if this is an output section.
303   void
304   set_out_shndx(unsigned int shndx)
305   { this->do_set_out_shndx(shndx); }
306
307   // Set the address and file offset of this data, and finalize the
308   // size of the data.  This is called during Layout::finalize for
309   // allocated sections.
310   void
311   set_address_and_file_offset(uint64_t addr, off_t off)
312   {
313     this->set_address(addr);
314     this->set_file_offset(off);
315     this->finalize_data_size();
316   }
317
318   // Set the address.
319   void
320   set_address(uint64_t addr)
321   {
322     gold_assert(!this->is_address_valid_);
323     this->address_ = addr;
324     this->is_address_valid_ = true;
325   }
326
327   // Set the file offset.
328   void
329   set_file_offset(off_t off)
330   {
331     gold_assert(!this->is_offset_valid_);
332     this->offset_ = off;
333     this->is_offset_valid_ = true;
334   }
335
336   // Update the data size without finalizing it.
337   void
338   pre_finalize_data_size()
339   {
340     if (!this->is_data_size_valid_)
341       {
342         // Tell the child class to update the data size.
343         this->update_data_size();
344       }
345   }
346
347   // Finalize the data size.
348   void
349   finalize_data_size()
350   {
351     if (!this->is_data_size_valid_)
352       {
353         // Tell the child class to set the data size.
354         this->set_final_data_size();
355         gold_assert(this->is_data_size_valid_);
356       }
357   }
358
359   // Set the TLS offset.  Called only for SHT_TLS sections.
360   void
361   set_tls_offset(uint64_t tls_base)
362   { this->do_set_tls_offset(tls_base); }
363
364   // Return the TLS offset, relative to the base of the TLS segment.
365   // Valid only for SHT_TLS sections.
366   uint64_t
367   tls_offset() const
368   { return this->do_tls_offset(); }
369
370   // Write the data to the output file.  This is called after
371   // Layout::finalize is complete.
372   void
373   write(Output_file* file)
374   { this->do_write(file); }
375
376   // This is called by Layout::finalize to note that the sizes of
377   // allocated sections must now be fixed.
378   static void
379   layout_complete()
380   { Output_data::allocated_sizes_are_fixed = true; }
381
382   // Used to check that layout has been done.
383   static bool
384   is_layout_complete()
385   { return Output_data::allocated_sizes_are_fixed; }
386
387   // Note that a dynamic reloc has been applied to this data.
388   void
389   add_dynamic_reloc()
390   { this->has_dynamic_reloc_ = true; }
391
392   // Return whether a dynamic reloc has been applied.
393   bool
394   has_dynamic_reloc() const
395   { return this->has_dynamic_reloc_; }
396
397   // Whether the address is valid.
398   bool
399   is_address_valid() const
400   { return this->is_address_valid_; }
401
402   // Whether the file offset is valid.
403   bool
404   is_offset_valid() const
405   { return this->is_offset_valid_; }
406
407   // Whether the data size is valid.
408   bool
409   is_data_size_valid() const
410   { return this->is_data_size_valid_; }
411
412   // Print information to the map file.
413   void
414   print_to_mapfile(Mapfile* mapfile) const
415   { return this->do_print_to_mapfile(mapfile); }
416
417  protected:
418   // Functions that child classes may or in some cases must implement.
419
420   // Write the data to the output file.
421   virtual void
422   do_write(Output_file*) = 0;
423
424   // Return the required alignment.
425   virtual uint64_t
426   do_addralign() const = 0;
427
428   // Return whether this has a load address.
429   virtual bool
430   do_has_load_address() const
431   { return false; }
432
433   // Return the load address.
434   virtual uint64_t
435   do_load_address() const
436   { gold_unreachable(); }
437
438   // Return whether this is an Output_section.
439   virtual bool
440   do_is_section() const
441   { return false; }
442
443   // Return whether this is an Output_section of the specified type.
444   // This only needs to be implement by Output_section.
445   virtual bool
446   do_is_section_type(elfcpp::Elf_Word) const
447   { return false; }
448
449   // Return whether this is an Output_section with the specific flag
450   // set.  This only needs to be implemented by Output_section.
451   virtual bool
452   do_is_section_flag_set(elfcpp::Elf_Xword) const
453   { return false; }
454
455   // Return the output section, if there is one.
456   virtual Output_section*
457   do_output_section()
458   { return NULL; }
459
460   virtual const Output_section*
461   do_output_section() const
462   { return NULL; }
463
464   // Return the output section index, if there is an output section.
465   virtual unsigned int
466   do_out_shndx() const
467   { gold_unreachable(); }
468
469   // Set the output section index, if this is an output section.
470   virtual void
471   do_set_out_shndx(unsigned int)
472   { gold_unreachable(); }
473
474   // This is a hook for derived classes to set the preliminary data size.
475   // This is called by pre_finalize_data_size, normally called during
476   // Layout::finalize, before the section address is set, and is used
477   // during an incremental update, when we need to know the size of a
478   // section before allocating space in the output file.  For classes
479   // where the current data size is up to date, this default version of
480   // the method can be inherited.
481   virtual void
482   update_data_size()
483   { }
484
485   // This is a hook for derived classes to set the data size.  This is
486   // called by finalize_data_size, normally called during
487   // Layout::finalize, when the section address is set.
488   virtual void
489   set_final_data_size()
490   { gold_unreachable(); }
491
492   // A hook for resetting the address and file offset.
493   virtual void
494   do_reset_address_and_file_offset()
495   { }
496
497   // Return true if address and file offset already have reset values. In
498   // other words, calling reset_address_and_file_offset will not change them.
499   // A child class overriding do_reset_address_and_file_offset may need to
500   // also override this.
501   virtual bool
502   do_address_and_file_offset_have_reset_values() const
503   { return !this->is_address_valid_ && !this->is_offset_valid_; }
504
505   // Set the TLS offset.  Called only for SHT_TLS sections.
506   virtual void
507   do_set_tls_offset(uint64_t)
508   { gold_unreachable(); }
509
510   // Return the TLS offset, relative to the base of the TLS segment.
511   // Valid only for SHT_TLS sections.
512   virtual uint64_t
513   do_tls_offset() const
514   { gold_unreachable(); }
515
516   // Print to the map file.  This only needs to be implemented by
517   // classes which may appear in a PT_LOAD segment.
518   virtual void
519   do_print_to_mapfile(Mapfile*) const
520   { gold_unreachable(); }
521
522   // Functions that child classes may call.
523
524   // Reset the address.  The Output_section class needs this when an
525   // SHF_ALLOC input section is added to an output section which was
526   // formerly not SHF_ALLOC.
527   void
528   mark_address_invalid()
529   { this->is_address_valid_ = false; }
530
531   // Set the size of the data.
532   void
533   set_data_size(off_t data_size)
534   {
535     gold_assert(!this->is_data_size_valid_
536                 && !this->is_data_size_fixed_);
537     this->data_size_ = data_size;
538     this->is_data_size_valid_ = true;
539   }
540
541   // Fix the data size.  Once it is fixed, it cannot be changed
542   // and the data size remains always valid.
543   void
544   fix_data_size()
545   {
546     gold_assert(this->is_data_size_valid_);
547     this->is_data_size_fixed_ = true;
548   }
549
550   // Get the current data size--this is for the convenience of
551   // sections which build up their size over time.
552   off_t
553   current_data_size_for_child() const
554   { return this->data_size_; }
555
556   // Set the current data size--this is for the convenience of
557   // sections which build up their size over time.
558   void
559   set_current_data_size_for_child(off_t data_size)
560   {
561     gold_assert(!this->is_data_size_valid_);
562     this->data_size_ = data_size;
563   }
564
565   // Return default alignment for the target size.
566   static uint64_t
567   default_alignment();
568
569   // Return default alignment for a specified size--32 or 64.
570   static uint64_t
571   default_alignment_for_size(int size);
572
573  private:
574   Output_data(const Output_data&);
575   Output_data& operator=(const Output_data&);
576
577   // This is used for verification, to make sure that we don't try to
578   // change any sizes of allocated sections after we set the section
579   // addresses.
580   static bool allocated_sizes_are_fixed;
581
582   // Memory address in output file.
583   uint64_t address_;
584   // Size of data in output file.
585   off_t data_size_;
586   // File offset of contents in output file.
587   off_t offset_;
588   // Whether address_ is valid.
589   bool is_address_valid_ : 1;
590   // Whether data_size_ is valid.
591   bool is_data_size_valid_ : 1;
592   // Whether offset_ is valid.
593   bool is_offset_valid_ : 1;
594   // Whether data size is fixed.
595   bool is_data_size_fixed_ : 1;
596   // Whether any dynamic relocs have been applied to this section.
597   bool has_dynamic_reloc_ : 1;
598 };
599
600 // Output the section headers.
601
602 class Output_section_headers : public Output_data
603 {
604  public:
605   Output_section_headers(const Layout*,
606                          const Layout::Segment_list*,
607                          const Layout::Section_list*,
608                          const Layout::Section_list*,
609                          const Stringpool*,
610                          const Output_section*);
611
612  protected:
613   // Write the data to the file.
614   void
615   do_write(Output_file*);
616
617   // Return the required alignment.
618   uint64_t
619   do_addralign() const
620   { return Output_data::default_alignment(); }
621
622   // Write to a map file.
623   void
624   do_print_to_mapfile(Mapfile* mapfile) const
625   { mapfile->print_output_data(this, _("** section headers")); }
626
627   // Update the data size.
628   void
629   update_data_size()
630   { this->set_data_size(this->do_size()); }
631
632   // Set final data size.
633   void
634   set_final_data_size()
635   { this->set_data_size(this->do_size()); }
636
637  private:
638   // Write the data to the file with the right size and endianness.
639   template<int size, bool big_endian>
640   void
641   do_sized_write(Output_file*);
642
643   // Compute data size.
644   off_t
645   do_size() const;
646
647   const Layout* layout_;
648   const Layout::Segment_list* segment_list_;
649   const Layout::Section_list* section_list_;
650   const Layout::Section_list* unattached_section_list_;
651   const Stringpool* secnamepool_;
652   const Output_section* shstrtab_section_;
653 };
654
655 // Output the segment headers.
656
657 class Output_segment_headers : public Output_data
658 {
659  public:
660   Output_segment_headers(const Layout::Segment_list& segment_list);
661
662  protected:
663   // Write the data to the file.
664   void
665   do_write(Output_file*);
666
667   // Return the required alignment.
668   uint64_t
669   do_addralign() const
670   { return Output_data::default_alignment(); }
671
672   // Write to a map file.
673   void
674   do_print_to_mapfile(Mapfile* mapfile) const
675   { mapfile->print_output_data(this, _("** segment headers")); }
676
677   // Set final data size.
678   void
679   set_final_data_size()
680   { this->set_data_size(this->do_size()); }
681
682  private:
683   // Write the data to the file with the right size and endianness.
684   template<int size, bool big_endian>
685   void
686   do_sized_write(Output_file*);
687
688   // Compute the current size.
689   off_t
690   do_size() const;
691
692   const Layout::Segment_list& segment_list_;
693 };
694
695 // Output the ELF file header.
696
697 class Output_file_header : public Output_data
698 {
699  public:
700   Output_file_header(Target*,
701                      const Symbol_table*,
702                      const Output_segment_headers*);
703
704   // Add information about the section headers.  We lay out the ELF
705   // file header before we create the section headers.
706   void set_section_info(const Output_section_headers*,
707                         const Output_section* shstrtab);
708
709  protected:
710   // Write the data to the file.
711   void
712   do_write(Output_file*);
713
714   // Return the required alignment.
715   uint64_t
716   do_addralign() const
717   { return Output_data::default_alignment(); }
718
719   // Write to a map file.
720   void
721   do_print_to_mapfile(Mapfile* mapfile) const
722   { mapfile->print_output_data(this, _("** file header")); }
723
724   // Set final data size.
725   void
726   set_final_data_size(void)
727   { this->set_data_size(this->do_size()); }
728
729  private:
730   // Write the data to the file with the right size and endianness.
731   template<int size, bool big_endian>
732   void
733   do_sized_write(Output_file*);
734
735   // Return the value to use for the entry address.
736   template<int size>
737   typename elfcpp::Elf_types<size>::Elf_Addr
738   entry();
739
740   // Compute the current data size.
741   off_t
742   do_size() const;
743
744   Target* target_;
745   const Symbol_table* symtab_;
746   const Output_segment_headers* segment_header_;
747   const Output_section_headers* section_header_;
748   const Output_section* shstrtab_;
749 };
750
751 // Output sections are mainly comprised of input sections.  However,
752 // there are cases where we have data to write out which is not in an
753 // input section.  Output_section_data is used in such cases.  This is
754 // an abstract base class.
755
756 class Output_section_data : public Output_data
757 {
758  public:
759   Output_section_data(off_t data_size, uint64_t addralign,
760                       bool is_data_size_fixed)
761     : Output_data(), output_section_(NULL), addralign_(addralign)
762   {
763     this->set_data_size(data_size);
764     if (is_data_size_fixed)
765       this->fix_data_size();
766   }
767
768   Output_section_data(uint64_t addralign)
769     : Output_data(), output_section_(NULL), addralign_(addralign)
770   { }
771
772   // Return the output section.
773   Output_section*
774   output_section()
775   { return this->output_section_; }
776
777   const Output_section*
778   output_section() const
779   { return this->output_section_; }
780
781   // Record the output section.
782   void
783   set_output_section(Output_section* os);
784
785   // Add an input section, for SHF_MERGE sections.  This returns true
786   // if the section was handled.
787   bool
788   add_input_section(Relobj* object, unsigned int shndx)
789   { return this->do_add_input_section(object, shndx); }
790
791   // Given an input OBJECT, an input section index SHNDX within that
792   // object, and an OFFSET relative to the start of that input
793   // section, return whether or not the corresponding offset within
794   // the output section is known.  If this function returns true, it
795   // sets *POUTPUT to the output offset.  The value -1 indicates that
796   // this input offset is being discarded.
797   bool
798   output_offset(const Relobj* object, unsigned int shndx,
799                 section_offset_type offset,
800                 section_offset_type* poutput) const
801   { return this->do_output_offset(object, shndx, offset, poutput); }
802
803   // Write the contents to a buffer.  This is used for sections which
804   // require postprocessing, such as compression.
805   void
806   write_to_buffer(unsigned char* buffer)
807   { this->do_write_to_buffer(buffer); }
808
809   // Print merge stats to stderr.  This should only be called for
810   // SHF_MERGE sections.
811   void
812   print_merge_stats(const char* section_name)
813   { this->do_print_merge_stats(section_name); }
814
815  protected:
816   // The child class must implement do_write.
817
818   // The child class may implement specific adjustments to the output
819   // section.
820   virtual void
821   do_adjust_output_section(Output_section*)
822   { }
823
824   // May be implemented by child class.  Return true if the section
825   // was handled.
826   virtual bool
827   do_add_input_section(Relobj*, unsigned int)
828   { gold_unreachable(); }
829
830   // The child class may implement output_offset.
831   virtual bool
832   do_output_offset(const Relobj*, unsigned int, section_offset_type,
833                    section_offset_type*) const
834   { return false; }
835
836   // The child class may implement write_to_buffer.  Most child
837   // classes can not appear in a compressed section, and they do not
838   // implement this.
839   virtual void
840   do_write_to_buffer(unsigned char*)
841   { gold_unreachable(); }
842
843   // Print merge statistics.
844   virtual void
845   do_print_merge_stats(const char*)
846   { gold_unreachable(); }
847
848   // Return the required alignment.
849   uint64_t
850   do_addralign() const
851   { return this->addralign_; }
852
853   // Return the output section.
854   Output_section*
855   do_output_section()
856   { return this->output_section_; }
857
858   const Output_section*
859   do_output_section() const
860   { return this->output_section_; }
861
862   // Return the section index of the output section.
863   unsigned int
864   do_out_shndx() const;
865
866   // Set the alignment.
867   void
868   set_addralign(uint64_t addralign);
869
870  private:
871   // The output section for this section.
872   Output_section* output_section_;
873   // The required alignment.
874   uint64_t addralign_;
875 };
876
877 // Some Output_section_data classes build up their data step by step,
878 // rather than all at once.  This class provides an interface for
879 // them.
880
881 class Output_section_data_build : public Output_section_data
882 {
883  public:
884   Output_section_data_build(uint64_t addralign)
885     : Output_section_data(addralign)
886   { }
887
888   Output_section_data_build(off_t data_size, uint64_t addralign)
889     : Output_section_data(data_size, addralign, false)
890   { }
891
892   // Set the current data size.
893   void
894   set_current_data_size(off_t data_size)
895   { this->set_current_data_size_for_child(data_size); }
896
897  protected:
898   // Set the final data size.
899   virtual void
900   set_final_data_size()
901   { this->set_data_size(this->current_data_size_for_child()); }
902 };
903
904 // A simple case of Output_data in which we have constant data to
905 // output.
906
907 class Output_data_const : public Output_section_data
908 {
909  public:
910   Output_data_const(const std::string& data, uint64_t addralign)
911     : Output_section_data(data.size(), addralign, true), data_(data)
912   { }
913
914   Output_data_const(const char* p, off_t len, uint64_t addralign)
915     : Output_section_data(len, addralign, true), data_(p, len)
916   { }
917
918   Output_data_const(const unsigned char* p, off_t len, uint64_t addralign)
919     : Output_section_data(len, addralign, true),
920       data_(reinterpret_cast<const char*>(p), len)
921   { }
922
923  protected:
924   // Write the data to the output file.
925   void
926   do_write(Output_file*);
927
928   // Write the data to a buffer.
929   void
930   do_write_to_buffer(unsigned char* buffer)
931   { memcpy(buffer, this->data_.data(), this->data_.size()); }
932
933   // Write to a map file.
934   void
935   do_print_to_mapfile(Mapfile* mapfile) const
936   { mapfile->print_output_data(this, _("** fill")); }
937
938  private:
939   std::string data_;
940 };
941
942 // Another version of Output_data with constant data, in which the
943 // buffer is allocated by the caller.
944
945 class Output_data_const_buffer : public Output_section_data
946 {
947  public:
948   Output_data_const_buffer(const unsigned char* p, off_t len,
949                            uint64_t addralign, const char* map_name)
950     : Output_section_data(len, addralign, true),
951       p_(p), map_name_(map_name)
952   { }
953
954  protected:
955   // Write the data the output file.
956   void
957   do_write(Output_file*);
958
959   // Write the data to a buffer.
960   void
961   do_write_to_buffer(unsigned char* buffer)
962   { memcpy(buffer, this->p_, this->data_size()); }
963
964   // Write to a map file.
965   void
966   do_print_to_mapfile(Mapfile* mapfile) const
967   { mapfile->print_output_data(this, _(this->map_name_)); }
968
969  private:
970   // The data to output.
971   const unsigned char* p_;
972   // Name to use in a map file.  Maps are a rarely used feature, but
973   // the space usage is minor as aren't very many of these objects.
974   const char* map_name_;
975 };
976
977 // A place holder for a fixed amount of data written out via some
978 // other mechanism.
979
980 class Output_data_fixed_space : public Output_section_data
981 {
982  public:
983   Output_data_fixed_space(off_t data_size, uint64_t addralign,
984                           const char* map_name)
985     : Output_section_data(data_size, addralign, true),
986       map_name_(map_name)
987   { }
988
989  protected:
990   // Write out the data--the actual data must be written out
991   // elsewhere.
992   void
993   do_write(Output_file*)
994   { }
995
996   // Write to a map file.
997   void
998   do_print_to_mapfile(Mapfile* mapfile) const
999   { mapfile->print_output_data(this, _(this->map_name_)); }
1000
1001  private:
1002   // Name to use in a map file.  Maps are a rarely used feature, but
1003   // the space usage is minor as aren't very many of these objects.
1004   const char* map_name_;
1005 };
1006
1007 // A place holder for variable sized data written out via some other
1008 // mechanism.
1009
1010 class Output_data_space : public Output_section_data_build
1011 {
1012  public:
1013   explicit Output_data_space(uint64_t addralign, const char* map_name)
1014     : Output_section_data_build(addralign),
1015       map_name_(map_name)
1016   { }
1017
1018   explicit Output_data_space(off_t data_size, uint64_t addralign,
1019                              const char* map_name)
1020     : Output_section_data_build(data_size, addralign),
1021       map_name_(map_name)
1022   { }
1023
1024   // Set the alignment.
1025   void
1026   set_space_alignment(uint64_t align)
1027   { this->set_addralign(align); }
1028
1029  protected:
1030   // Write out the data--the actual data must be written out
1031   // elsewhere.
1032   void
1033   do_write(Output_file*)
1034   { }
1035
1036   // Write to a map file.
1037   void
1038   do_print_to_mapfile(Mapfile* mapfile) const
1039   { mapfile->print_output_data(this, _(this->map_name_)); }
1040
1041  private:
1042   // Name to use in a map file.  Maps are a rarely used feature, but
1043   // the space usage is minor as aren't very many of these objects.
1044   const char* map_name_;
1045 };
1046
1047 // Fill fixed space with zeroes.  This is just like
1048 // Output_data_fixed_space, except that the map name is known.
1049
1050 class Output_data_zero_fill : public Output_section_data
1051 {
1052  public:
1053   Output_data_zero_fill(off_t data_size, uint64_t addralign)
1054     : Output_section_data(data_size, addralign, true)
1055   { }
1056
1057  protected:
1058   // There is no data to write out.
1059   void
1060   do_write(Output_file*)
1061   { }
1062
1063   // Write to a map file.
1064   void
1065   do_print_to_mapfile(Mapfile* mapfile) const
1066   { mapfile->print_output_data(this, "** zero fill"); }
1067 };
1068
1069 // A string table which goes into an output section.
1070
1071 class Output_data_strtab : public Output_section_data
1072 {
1073  public:
1074   Output_data_strtab(Stringpool* strtab)
1075     : Output_section_data(1), strtab_(strtab)
1076   { }
1077
1078  protected:
1079   // This is called to update the section size prior to assigning
1080   // the address and file offset.
1081   void
1082   update_data_size()
1083   { this->set_final_data_size(); }
1084
1085   // This is called to set the address and file offset.  Here we make
1086   // sure that the Stringpool is finalized.
1087   void
1088   set_final_data_size();
1089
1090   // Write out the data.
1091   void
1092   do_write(Output_file*);
1093
1094   // Write the data to a buffer.
1095   void
1096   do_write_to_buffer(unsigned char* buffer)
1097   { this->strtab_->write_to_buffer(buffer, this->data_size()); }
1098
1099   // Write to a map file.
1100   void
1101   do_print_to_mapfile(Mapfile* mapfile) const
1102   { mapfile->print_output_data(this, _("** string table")); }
1103
1104  private:
1105   Stringpool* strtab_;
1106 };
1107
1108 // This POD class is used to represent a single reloc in the output
1109 // file.  This could be a private class within Output_data_reloc, but
1110 // the templatization is complex enough that I broke it out into a
1111 // separate class.  The class is templatized on either elfcpp::SHT_REL
1112 // or elfcpp::SHT_RELA, and also on whether this is a dynamic
1113 // relocation or an ordinary relocation.
1114
1115 // A relocation can be against a global symbol, a local symbol, a
1116 // local section symbol, an output section, or the undefined symbol at
1117 // index 0.  We represent the latter by using a NULL global symbol.
1118
1119 template<int sh_type, bool dynamic, int size, bool big_endian>
1120 class Output_reloc;
1121
1122 template<bool dynamic, int size, bool big_endian>
1123 class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
1124 {
1125  public:
1126   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
1127   typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
1128
1129   static const Address invalid_address = static_cast<Address>(0) - 1;
1130
1131   // An uninitialized entry.  We need this because we want to put
1132   // instances of this class into an STL container.
1133   Output_reloc()
1134     : local_sym_index_(INVALID_CODE)
1135   { }
1136
1137   // We have a bunch of different constructors.  They come in pairs
1138   // depending on how the address of the relocation is specified.  It
1139   // can either be an offset in an Output_data or an offset in an
1140   // input section.
1141
1142   // A reloc against a global symbol.
1143
1144   Output_reloc(Symbol* gsym, unsigned int type, Output_data* od,
1145                Address address, bool is_relative, bool is_symbolless,
1146                bool use_plt_offset);
1147
1148   Output_reloc(Symbol* gsym, unsigned int type,
1149                Sized_relobj<size, big_endian>* relobj,
1150                unsigned int shndx, Address address, bool is_relative,
1151                bool is_symbolless, bool use_plt_offset);
1152
1153   // A reloc against a local symbol or local section symbol.
1154
1155   Output_reloc(Sized_relobj<size, big_endian>* relobj,
1156                unsigned int local_sym_index, unsigned int type,
1157                Output_data* od, Address address, bool is_relative,
1158                bool is_symbolless, bool is_section_symbol,
1159                bool use_plt_offset);
1160
1161   Output_reloc(Sized_relobj<size, big_endian>* relobj,
1162                unsigned int local_sym_index, unsigned int type,
1163                unsigned int shndx, Address address, bool is_relative,
1164                bool is_symbolless, bool is_section_symbol,
1165                bool use_plt_offset);
1166
1167   // A reloc against the STT_SECTION symbol of an output section.
1168
1169   Output_reloc(Output_section* os, unsigned int type, Output_data* od,
1170                Address address, bool is_relative);
1171
1172   Output_reloc(Output_section* os, unsigned int type,
1173                Sized_relobj<size, big_endian>* relobj, unsigned int shndx,
1174                Address address, bool is_relative);
1175
1176   // An absolute or relative relocation with no symbol.
1177
1178   Output_reloc(unsigned int type, Output_data* od, Address address,
1179                bool is_relative);
1180
1181   Output_reloc(unsigned int type, Sized_relobj<size, big_endian>* relobj,
1182                unsigned int shndx, Address address, bool is_relative);
1183
1184   // A target specific relocation.  The target will be called to get
1185   // the symbol index, passing ARG.  The type and offset will be set
1186   // as for other relocation types.
1187
1188   Output_reloc(unsigned int type, void* arg, Output_data* od,
1189                Address address);
1190
1191   Output_reloc(unsigned int type, void* arg,
1192                Sized_relobj<size, big_endian>* relobj,
1193                unsigned int shndx, Address address);
1194
1195   // Return the reloc type.
1196   unsigned int
1197   type() const
1198   { return this->type_; }
1199
1200   // Return whether this is a RELATIVE relocation.
1201   bool
1202   is_relative() const
1203   { return this->is_relative_; }
1204
1205   // Return whether this is a relocation which should not use
1206   // a symbol, but which obtains its addend from a symbol.
1207   bool
1208   is_symbolless() const
1209   { return this->is_symbolless_; }
1210
1211   // Return whether this is against a local section symbol.
1212   bool
1213   is_local_section_symbol() const
1214   {
1215     return (this->local_sym_index_ != GSYM_CODE
1216             && this->local_sym_index_ != SECTION_CODE
1217             && this->local_sym_index_ != INVALID_CODE
1218             && this->local_sym_index_ != TARGET_CODE
1219             && this->is_section_symbol_);
1220   }
1221
1222   // Return whether this is a target specific relocation.
1223   bool
1224   is_target_specific() const
1225   { return this->local_sym_index_ == TARGET_CODE; }
1226
1227   // Return the argument to pass to the target for a target specific
1228   // relocation.
1229   void*
1230   target_arg() const
1231   {
1232     gold_assert(this->local_sym_index_ == TARGET_CODE);
1233     return this->u1_.arg;
1234   }
1235
1236   // For a local section symbol, return the offset of the input
1237   // section within the output section.  ADDEND is the addend being
1238   // applied to the input section.
1239   Address
1240   local_section_offset(Addend addend) const;
1241
1242   // Get the value of the symbol referred to by a Rel relocation when
1243   // we are adding the given ADDEND.
1244   Address
1245   symbol_value(Addend addend) const;
1246
1247   // If this relocation is against an input section, return the
1248   // relocatable object containing the input section.
1249   Sized_relobj<size, big_endian>*
1250   get_relobj() const
1251   {
1252     if (this->shndx_ == INVALID_CODE)
1253       return NULL;
1254     return this->u2_.relobj;
1255   }
1256
1257   // Write the reloc entry to an output view.
1258   void
1259   write(unsigned char* pov) const;
1260
1261   // Write the offset and info fields to Write_rel.
1262   template<typename Write_rel>
1263   void write_rel(Write_rel*) const;
1264
1265   // This is used when sorting dynamic relocs.  Return -1 to sort this
1266   // reloc before R2, 0 to sort the same as R2, 1 to sort after R2.
1267   int
1268   compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2)
1269     const;
1270
1271   // Return whether this reloc should be sorted before the argument
1272   // when sorting dynamic relocs.
1273   bool
1274   sort_before(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>&
1275               r2) const
1276   { return this->compare(r2) < 0; }
1277
1278   // Return the symbol index.
1279   unsigned int
1280   get_symbol_index() const;
1281
1282   // Return the output address.
1283   Address
1284   get_address() const;
1285
1286  private:
1287   // Record that we need a dynamic symbol index.
1288   void
1289   set_needs_dynsym_index();
1290
1291   // Codes for local_sym_index_.
1292   enum
1293   {
1294     // Global symbol.
1295     GSYM_CODE = -1U,
1296     // Output section.
1297     SECTION_CODE = -2U,
1298     // Target specific.
1299     TARGET_CODE = -3U,
1300     // Invalid uninitialized entry.
1301     INVALID_CODE = -4U
1302   };
1303
1304   union
1305   {
1306     // For a local symbol or local section symbol
1307     // (this->local_sym_index_ >= 0), the object.  We will never
1308     // generate a relocation against a local symbol in a dynamic
1309     // object; that doesn't make sense.  And our callers will always
1310     // be templatized, so we use Sized_relobj here.
1311     Sized_relobj<size, big_endian>* relobj;
1312     // For a global symbol (this->local_sym_index_ == GSYM_CODE, the
1313     // symbol.  If this is NULL, it indicates a relocation against the
1314     // undefined 0 symbol.
1315     Symbol* gsym;
1316     // For a relocation against an output section
1317     // (this->local_sym_index_ == SECTION_CODE), the output section.
1318     Output_section* os;
1319     // For a target specific relocation, an argument to pass to the
1320     // target.
1321     void* arg;
1322   } u1_;
1323   union
1324   {
1325     // If this->shndx_ is not INVALID CODE, the object which holds the
1326     // input section being used to specify the reloc address.
1327     Sized_relobj<size, big_endian>* relobj;
1328     // If this->shndx_ is INVALID_CODE, the output data being used to
1329     // specify the reloc address.  This may be NULL if the reloc
1330     // address is absolute.
1331     Output_data* od;
1332   } u2_;
1333   // The address offset within the input section or the Output_data.
1334   Address address_;
1335   // This is GSYM_CODE for a global symbol, or SECTION_CODE for a
1336   // relocation against an output section, or TARGET_CODE for a target
1337   // specific relocation, or INVALID_CODE for an uninitialized value.
1338   // Otherwise, for a local symbol (this->is_section_symbol_ is
1339   // false), the local symbol index.  For a local section symbol
1340   // (this->is_section_symbol_ is true), the section index in the
1341   // input file.
1342   unsigned int local_sym_index_;
1343   // The reloc type--a processor specific code.
1344   unsigned int type_ : 28;
1345   // True if the relocation is a RELATIVE relocation.
1346   bool is_relative_ : 1;
1347   // True if the relocation is one which should not use
1348   // a symbol, but which obtains its addend from a symbol.
1349   bool is_symbolless_ : 1;
1350   // True if the relocation is against a section symbol.
1351   bool is_section_symbol_ : 1;
1352   // True if the addend should be the PLT offset.
1353   // (Used only for RELA, but stored here for space.)
1354   bool use_plt_offset_ : 1;
1355   // If the reloc address is an input section in an object, the
1356   // section index.  This is INVALID_CODE if the reloc address is
1357   // specified in some other way.
1358   unsigned int shndx_;
1359 };
1360
1361 // The SHT_RELA version of Output_reloc<>.  This is just derived from
1362 // the SHT_REL version of Output_reloc, but it adds an addend.
1363
1364 template<bool dynamic, int size, bool big_endian>
1365 class Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
1366 {
1367  public:
1368   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
1369   typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
1370
1371   // An uninitialized entry.
1372   Output_reloc()
1373     : rel_()
1374   { }
1375
1376   // A reloc against a global symbol.
1377
1378   Output_reloc(Symbol* gsym, unsigned int type, Output_data* od,
1379                Address address, Addend addend, bool is_relative,
1380                bool is_symbolless, bool use_plt_offset)
1381     : rel_(gsym, type, od, address, is_relative, is_symbolless,
1382            use_plt_offset),
1383       addend_(addend)
1384   { }
1385
1386   Output_reloc(Symbol* gsym, unsigned int type,
1387                Sized_relobj<size, big_endian>* relobj,
1388                unsigned int shndx, Address address, Addend addend,
1389                bool is_relative, bool is_symbolless, bool use_plt_offset)
1390     : rel_(gsym, type, relobj, shndx, address, is_relative,
1391            is_symbolless, use_plt_offset), addend_(addend)
1392   { }
1393
1394   // A reloc against a local symbol.
1395
1396   Output_reloc(Sized_relobj<size, big_endian>* relobj,
1397                unsigned int local_sym_index, unsigned int type,
1398                Output_data* od, Address address,
1399                Addend addend, bool is_relative,
1400                bool is_symbolless, bool is_section_symbol,
1401                bool use_plt_offset)
1402     : rel_(relobj, local_sym_index, type, od, address, is_relative,
1403            is_symbolless, is_section_symbol, use_plt_offset),
1404       addend_(addend)
1405   { }
1406
1407   Output_reloc(Sized_relobj<size, big_endian>* relobj,
1408                unsigned int local_sym_index, unsigned int type,
1409                unsigned int shndx, Address address,
1410                Addend addend, bool is_relative,
1411                bool is_symbolless, bool is_section_symbol,
1412                bool use_plt_offset)
1413     : rel_(relobj, local_sym_index, type, shndx, address, is_relative,
1414            is_symbolless, is_section_symbol, use_plt_offset),
1415       addend_(addend)
1416   { }
1417
1418   // A reloc against the STT_SECTION symbol of an output section.
1419
1420   Output_reloc(Output_section* os, unsigned int type, Output_data* od,
1421                Address address, Addend addend, bool is_relative)
1422     : rel_(os, type, od, address, is_relative), addend_(addend)
1423   { }
1424
1425   Output_reloc(Output_section* os, unsigned int type,
1426                Sized_relobj<size, big_endian>* relobj,
1427                unsigned int shndx, Address address, Addend addend,
1428                bool is_relative)
1429     : rel_(os, type, relobj, shndx, address, is_relative), addend_(addend)
1430   { }
1431
1432   // An absolute or relative relocation with no symbol.
1433
1434   Output_reloc(unsigned int type, Output_data* od, Address address,
1435                Addend addend, bool is_relative)
1436     : rel_(type, od, address, is_relative), addend_(addend)
1437   { }
1438
1439   Output_reloc(unsigned int type, Sized_relobj<size, big_endian>* relobj,
1440                unsigned int shndx, Address address, Addend addend,
1441                bool is_relative)
1442     : rel_(type, relobj, shndx, address, is_relative), addend_(addend)
1443   { }
1444
1445   // A target specific relocation.  The target will be called to get
1446   // the symbol index and the addend, passing ARG.  The type and
1447   // offset will be set as for other relocation types.
1448
1449   Output_reloc(unsigned int type, void* arg, Output_data* od,
1450                Address address, Addend addend)
1451     : rel_(type, arg, od, address), addend_(addend)
1452   { }
1453
1454   Output_reloc(unsigned int type, void* arg,
1455                Sized_relobj<size, big_endian>* relobj,
1456                unsigned int shndx, Address address, Addend addend)
1457     : rel_(type, arg, relobj, shndx, address), addend_(addend)
1458   { }
1459
1460   // Return whether this is a RELATIVE relocation.
1461   bool
1462   is_relative() const
1463   { return this->rel_.is_relative(); }
1464
1465   // Return whether this is a relocation which should not use
1466   // a symbol, but which obtains its addend from a symbol.
1467   bool
1468   is_symbolless() const
1469   { return this->rel_.is_symbolless(); }
1470
1471   // If this relocation is against an input section, return the
1472   // relocatable object containing the input section.
1473   Sized_relobj<size, big_endian>*
1474   get_relobj() const
1475   { return this->rel_.get_relobj(); }
1476
1477   // Write the reloc entry to an output view.
1478   void
1479   write(unsigned char* pov) const;
1480
1481   // Return whether this reloc should be sorted before the argument
1482   // when sorting dynamic relocs.
1483   bool
1484   sort_before(const Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>&
1485               r2) const
1486   {
1487     int i = this->rel_.compare(r2.rel_);
1488     if (i < 0)
1489       return true;
1490     else if (i > 0)
1491       return false;
1492     else
1493       return this->addend_ < r2.addend_;
1494   }
1495
1496  private:
1497   // The basic reloc.
1498   Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> rel_;
1499   // The addend.
1500   Addend addend_;
1501 };
1502
1503 // Output_data_reloc_generic is a non-template base class for
1504 // Output_data_reloc_base.  This gives the generic code a way to hold
1505 // a pointer to a reloc section.
1506
1507 class Output_data_reloc_generic : public Output_section_data_build
1508 {
1509  public:
1510   Output_data_reloc_generic(int size, bool sort_relocs)
1511     : Output_section_data_build(Output_data::default_alignment_for_size(size)),
1512       relative_reloc_count_(0), sort_relocs_(sort_relocs)
1513   { }
1514
1515   // Return the number of relative relocs in this section.
1516   size_t
1517   relative_reloc_count() const
1518   { return this->relative_reloc_count_; }
1519
1520   // Whether we should sort the relocs.
1521   bool
1522   sort_relocs() const
1523   { return this->sort_relocs_; }
1524
1525   // Add a reloc of type TYPE against the global symbol GSYM.  The
1526   // relocation applies to the data at offset ADDRESS within OD.
1527   virtual void
1528   add_global_generic(Symbol* gsym, unsigned int type, Output_data* od,
1529                      uint64_t address, uint64_t addend) = 0;
1530
1531   // Add a reloc of type TYPE against the global symbol GSYM.  The
1532   // relocation applies to data at offset ADDRESS within section SHNDX
1533   // of object file RELOBJ.  OD is the associated output section.
1534   virtual void
1535   add_global_generic(Symbol* gsym, unsigned int type, Output_data* od,
1536                      Relobj* relobj, unsigned int shndx, uint64_t address,
1537                      uint64_t addend) = 0;
1538
1539   // Add a reloc of type TYPE against the local symbol LOCAL_SYM_INDEX
1540   // in RELOBJ.  The relocation applies to the data at offset ADDRESS
1541   // within OD.
1542   virtual void
1543   add_local_generic(Relobj* relobj, unsigned int local_sym_index,
1544                     unsigned int type, Output_data* od, uint64_t address,
1545                     uint64_t addend) = 0;
1546
1547   // Add a reloc of type TYPE against the local symbol LOCAL_SYM_INDEX
1548   // in RELOBJ.  The relocation applies to the data at offset ADDRESS
1549   // within section SHNDX of RELOBJ.  OD is the associated output
1550   // section.
1551   virtual void
1552   add_local_generic(Relobj* relobj, unsigned int local_sym_index,
1553                     unsigned int type, Output_data* od, unsigned int shndx,
1554                     uint64_t address, uint64_t addend) = 0;
1555
1556   // Add a reloc of type TYPE against the STT_SECTION symbol of the
1557   // output section OS.  The relocation applies to the data at offset
1558   // ADDRESS within OD.
1559   virtual void
1560   add_output_section_generic(Output_section *os, unsigned int type,
1561                              Output_data* od, uint64_t address,
1562                              uint64_t addend) = 0;
1563
1564   // Add a reloc of type TYPE against the STT_SECTION symbol of the
1565   // output section OS.  The relocation applies to the data at offset
1566   // ADDRESS within section SHNDX of RELOBJ.  OD is the associated
1567   // output section.
1568   virtual void
1569   add_output_section_generic(Output_section* os, unsigned int type,
1570                              Output_data* od, Relobj* relobj,
1571                              unsigned int shndx, uint64_t address,
1572                              uint64_t addend) = 0;
1573
1574  protected:
1575   // Note that we've added another relative reloc.
1576   void
1577   bump_relative_reloc_count()
1578   { ++this->relative_reloc_count_; }
1579
1580  private:
1581   // The number of relative relocs added to this section.  This is to
1582   // support DT_RELCOUNT.
1583   size_t relative_reloc_count_;
1584   // Whether to sort the relocations when writing them out, to make
1585   // the dynamic linker more efficient.
1586   bool sort_relocs_;
1587 };
1588
1589 // Output_data_reloc is used to manage a section containing relocs.
1590 // SH_TYPE is either elfcpp::SHT_REL or elfcpp::SHT_RELA.  DYNAMIC
1591 // indicates whether this is a dynamic relocation or a normal
1592 // relocation.  Output_data_reloc_base is a base class.
1593 // Output_data_reloc is the real class, which we specialize based on
1594 // the reloc type.
1595
1596 template<int sh_type, bool dynamic, int size, bool big_endian>
1597 class Output_data_reloc_base : public Output_data_reloc_generic
1598 {
1599  public:
1600   typedef Output_reloc<sh_type, dynamic, size, big_endian> Output_reloc_type;
1601   typedef typename Output_reloc_type::Address Address;
1602   static const int reloc_size =
1603     Reloc_types<sh_type, size, big_endian>::reloc_size;
1604
1605   // Construct the section.
1606   Output_data_reloc_base(bool sort_relocs)
1607     : Output_data_reloc_generic(size, sort_relocs)
1608   { }
1609
1610  protected:
1611   // Write out the data.
1612   void
1613   do_write(Output_file*);
1614
1615   // Generic implementation of do_write, allowing a customized
1616   // class for writing the output relocation (e.g., for MIPS-64).
1617   template<class Output_reloc_writer>
1618   void
1619   do_write_generic(Output_file* of)
1620   {
1621     const off_t off = this->offset();
1622     const off_t oview_size = this->data_size();
1623     unsigned char* const oview = of->get_output_view(off, oview_size);
1624
1625     if (this->sort_relocs())
1626       {
1627         gold_assert(dynamic);
1628         std::sort(this->relocs_.begin(), this->relocs_.end(),
1629                   Sort_relocs_comparison());
1630       }
1631
1632     unsigned char* pov = oview;
1633     for (typename Relocs::const_iterator p = this->relocs_.begin();
1634          p != this->relocs_.end();
1635          ++p)
1636       {
1637         Output_reloc_writer::write(p, pov);
1638         pov += reloc_size;
1639       }
1640
1641     gold_assert(pov - oview == oview_size);
1642
1643     of->write_output_view(off, oview_size, oview);
1644
1645     // We no longer need the relocation entries.
1646     this->relocs_.clear();
1647   }
1648
1649   // Set the entry size and the link.
1650   void
1651   do_adjust_output_section(Output_section* os);
1652
1653   // Write to a map file.
1654   void
1655   do_print_to_mapfile(Mapfile* mapfile) const
1656   {
1657     mapfile->print_output_data(this,
1658                                (dynamic
1659                                 ? _("** dynamic relocs")
1660                                 : _("** relocs")));
1661   }
1662
1663   // Add a relocation entry.
1664   void
1665   add(Output_data* od, const Output_reloc_type& reloc)
1666   {
1667     this->relocs_.push_back(reloc);
1668     this->set_current_data_size(this->relocs_.size() * reloc_size);
1669     if (dynamic)
1670       od->add_dynamic_reloc();
1671     if (reloc.is_relative())
1672       this->bump_relative_reloc_count();
1673     Sized_relobj<size, big_endian>* relobj = reloc.get_relobj();
1674     if (relobj != NULL)
1675       relobj->add_dyn_reloc(this->relocs_.size() - 1);
1676   }
1677
1678  private:
1679   typedef std::vector<Output_reloc_type> Relocs;
1680
1681   // The class used to sort the relocations.
1682   struct Sort_relocs_comparison
1683   {
1684     bool
1685     operator()(const Output_reloc_type& r1, const Output_reloc_type& r2) const
1686     { return r1.sort_before(r2); }
1687   };
1688
1689   // The relocations in this section.
1690   Relocs relocs_;
1691 };
1692
1693 // The class which callers actually create.
1694
1695 template<int sh_type, bool dynamic, int size, bool big_endian>
1696 class Output_data_reloc;
1697
1698 // The SHT_REL version of Output_data_reloc.
1699
1700 template<bool dynamic, int size, bool big_endian>
1701 class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
1702   : public Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size, big_endian>
1703 {
1704  private:
1705   typedef Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size,
1706                                  big_endian> Base;
1707
1708  public:
1709   typedef typename Base::Output_reloc_type Output_reloc_type;
1710   typedef typename Output_reloc_type::Address Address;
1711
1712   Output_data_reloc(bool sr)
1713     : Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size, big_endian>(sr)
1714   { }
1715
1716   // Add a reloc against a global symbol.
1717
1718   void
1719   add_global(Symbol* gsym, unsigned int type, Output_data* od, Address address)
1720   {
1721     this->add(od, Output_reloc_type(gsym, type, od, address,
1722                                     false, false, false));
1723   }
1724
1725   void
1726   add_global(Symbol* gsym, unsigned int type, Output_data* od,
1727              Sized_relobj<size, big_endian>* relobj,
1728              unsigned int shndx, Address address)
1729   {
1730     this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
1731                                     false, false, false));
1732   }
1733
1734   void
1735   add_global_generic(Symbol* gsym, unsigned int type, Output_data* od,
1736                      uint64_t address, uint64_t addend)
1737   {
1738     gold_assert(addend == 0);
1739     this->add(od, Output_reloc_type(gsym, type, od,
1740                                     convert_types<Address, uint64_t>(address),
1741                                     false, false, false));
1742   }
1743
1744   void
1745   add_global_generic(Symbol* gsym, unsigned int type, Output_data* od,
1746                      Relobj* relobj, unsigned int shndx, uint64_t address,
1747                      uint64_t addend)
1748   {
1749     gold_assert(addend == 0);
1750     Sized_relobj<size, big_endian>* sized_relobj =
1751       static_cast<Sized_relobj<size, big_endian>*>(relobj);
1752     this->add(od, Output_reloc_type(gsym, type, sized_relobj, shndx,
1753                                     convert_types<Address, uint64_t>(address),
1754                                     false, false, false));
1755   }
1756
1757   // Add a RELATIVE reloc against a global symbol.  The final relocation
1758   // will not reference the symbol.
1759
1760   void
1761   add_global_relative(Symbol* gsym, unsigned int type, Output_data* od,
1762                       Address address)
1763   {
1764     this->add(od, Output_reloc_type(gsym, type, od, address, true, true,
1765                                     false));
1766   }
1767
1768   void
1769   add_global_relative(Symbol* gsym, unsigned int type, Output_data* od,
1770                       Sized_relobj<size, big_endian>* relobj,
1771                       unsigned int shndx, Address address)
1772   {
1773     this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
1774                                     true, true, false));
1775   }
1776
1777   // Add a global relocation which does not use a symbol for the relocation,
1778   // but which gets its addend from a symbol.
1779
1780   void
1781   add_symbolless_global_addend(Symbol* gsym, unsigned int type,
1782                                Output_data* od, Address address)
1783   {
1784     this->add(od, Output_reloc_type(gsym, type, od, address, false, true,
1785                                     false));
1786   }
1787
1788   void
1789   add_symbolless_global_addend(Symbol* gsym, unsigned int type,
1790                                Output_data* od,
1791                                Sized_relobj<size, big_endian>* relobj,
1792                                unsigned int shndx, Address address)
1793   {
1794     this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
1795                                     false, true, false));
1796   }
1797
1798   // Add a reloc against a local symbol.
1799
1800   void
1801   add_local(Sized_relobj<size, big_endian>* relobj,
1802             unsigned int local_sym_index, unsigned int type,
1803             Output_data* od, Address address)
1804   {
1805     this->add(od, Output_reloc_type(relobj, local_sym_index, type, od,
1806                                     address, false, false, false, false));
1807   }
1808
1809   void
1810   add_local(Sized_relobj<size, big_endian>* relobj,
1811             unsigned int local_sym_index, unsigned int type,
1812             Output_data* od, unsigned int shndx, Address address)
1813   {
1814     this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
1815                                     address, false, false, false, false));
1816   }
1817
1818   void
1819   add_local_generic(Relobj* relobj, unsigned int local_sym_index,
1820                     unsigned int type, Output_data* od, uint64_t address,
1821                     uint64_t addend)
1822   {
1823     gold_assert(addend == 0);
1824     Sized_relobj<size, big_endian>* sized_relobj =
1825       static_cast<Sized_relobj<size, big_endian> *>(relobj);
1826     this->add(od, Output_reloc_type(sized_relobj, local_sym_index, type, od,
1827                                     convert_types<Address, uint64_t>(address),
1828                                     false, false, false, false));
1829   }
1830
1831   void
1832   add_local_generic(Relobj* relobj, unsigned int local_sym_index,
1833                     unsigned int type, Output_data* od, unsigned int shndx,
1834                     uint64_t address, uint64_t addend)
1835   {
1836     gold_assert(addend == 0);
1837     Sized_relobj<size, big_endian>* sized_relobj =
1838       static_cast<Sized_relobj<size, big_endian>*>(relobj);
1839     this->add(od, Output_reloc_type(sized_relobj, local_sym_index, type, shndx,
1840                                     convert_types<Address, uint64_t>(address),
1841                                     false, false, false, false));
1842   }
1843
1844   // Add a RELATIVE reloc against a local symbol.
1845
1846   void
1847   add_local_relative(Sized_relobj<size, big_endian>* relobj,
1848                      unsigned int local_sym_index, unsigned int type,
1849                      Output_data* od, Address address)
1850   {
1851     this->add(od, Output_reloc_type(relobj, local_sym_index, type, od,
1852                                     address, true, true, false, false));
1853   }
1854
1855   void
1856   add_local_relative(Sized_relobj<size, big_endian>* relobj,
1857                      unsigned int local_sym_index, unsigned int type,
1858                      Output_data* od, unsigned int shndx, Address address)
1859   {
1860     this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
1861                                     address, true, true, false, false));
1862   }
1863
1864   void
1865   add_local_relative(Sized_relobj<size, big_endian>* relobj,
1866                      unsigned int local_sym_index, unsigned int type,
1867                      Output_data* od, unsigned int shndx, Address address,
1868                      bool use_plt_offset)
1869   {
1870     this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
1871                                     address, true, true, false,
1872                                     use_plt_offset));
1873   }
1874
1875   // Add a local relocation which does not use a symbol for the relocation,
1876   // but which gets its addend from a symbol.
1877
1878   void
1879   add_symbolless_local_addend(Sized_relobj<size, big_endian>* relobj,
1880                               unsigned int local_sym_index, unsigned int type,
1881                               Output_data* od, Address address)
1882   {
1883     this->add(od, Output_reloc_type(relobj, local_sym_index, type, od,
1884                                     address, false, true, false, false));
1885   }
1886
1887   void
1888   add_symbolless_local_addend(Sized_relobj<size, big_endian>* relobj,
1889                               unsigned int local_sym_index, unsigned int type,
1890                               Output_data* od, unsigned int shndx,
1891                               Address address)
1892   {
1893     this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
1894                                     address, false, true, false, false));
1895   }
1896
1897   // Add a reloc against a local section symbol.  This will be
1898   // converted into a reloc against the STT_SECTION symbol of the
1899   // output section.
1900
1901   void
1902   add_local_section(Sized_relobj<size, big_endian>* relobj,
1903                     unsigned int input_shndx, unsigned int type,
1904                     Output_data* od, Address address)
1905   {
1906     this->add(od, Output_reloc_type(relobj, input_shndx, type, od,
1907                                     address, false, false, true, false));
1908   }
1909
1910   void
1911   add_local_section(Sized_relobj<size, big_endian>* relobj,
1912                     unsigned int input_shndx, unsigned int type,
1913                     Output_data* od, unsigned int shndx, Address address)
1914   {
1915     this->add(od, Output_reloc_type(relobj, input_shndx, type, shndx,
1916                                     address, false, false, true, false));
1917   }
1918
1919   // A reloc against the STT_SECTION symbol of an output section.
1920   // OS is the Output_section that the relocation refers to; OD is
1921   // the Output_data object being relocated.
1922
1923   void
1924   add_output_section(Output_section* os, unsigned int type,
1925                      Output_data* od, Address address)
1926   { this->add(od, Output_reloc_type(os, type, od, address, false)); }
1927
1928   void
1929   add_output_section(Output_section* os, unsigned int type, Output_data* od,
1930                      Sized_relobj<size, big_endian>* relobj,
1931                      unsigned int shndx, Address address)
1932   { this->add(od, Output_reloc_type(os, type, relobj, shndx, address, false)); }
1933
1934   void
1935   add_output_section_generic(Output_section* os, unsigned int type,
1936                              Output_data* od, uint64_t address,
1937                              uint64_t addend)
1938   {
1939     gold_assert(addend == 0);
1940     this->add(od, Output_reloc_type(os, type, od,
1941                                     convert_types<Address, uint64_t>(address),
1942                                     false));
1943   }
1944
1945   void
1946   add_output_section_generic(Output_section* os, unsigned int type,
1947                              Output_data* od, Relobj* relobj,
1948                              unsigned int shndx, uint64_t address,
1949                              uint64_t addend)
1950   {
1951     gold_assert(addend == 0);
1952     Sized_relobj<size, big_endian>* sized_relobj =
1953       static_cast<Sized_relobj<size, big_endian>*>(relobj);
1954     this->add(od, Output_reloc_type(os, type, sized_relobj, shndx,
1955                                     convert_types<Address, uint64_t>(address),
1956                                     false));
1957   }
1958
1959   // As above, but the reloc TYPE is relative
1960
1961   void
1962   add_output_section_relative(Output_section* os, unsigned int type,
1963                               Output_data* od, Address address)
1964   { this->add(od, Output_reloc_type(os, type, od, address, true)); }
1965
1966   void
1967   add_output_section_relative(Output_section* os, unsigned int type,
1968                               Output_data* od,
1969                               Sized_relobj<size, big_endian>* relobj,
1970                               unsigned int shndx, Address address)
1971   { this->add(od, Output_reloc_type(os, type, relobj, shndx, address, true)); }
1972
1973   // Add an absolute relocation.
1974
1975   void
1976   add_absolute(unsigned int type, Output_data* od, Address address)
1977   { this->add(od, Output_reloc_type(type, od, address, false)); }
1978
1979   void
1980   add_absolute(unsigned int type, Output_data* od,
1981                Sized_relobj<size, big_endian>* relobj,
1982                unsigned int shndx, Address address)
1983   { this->add(od, Output_reloc_type(type, relobj, shndx, address, false)); }
1984
1985   // Add a relative relocation
1986
1987   void
1988   add_relative(unsigned int type, Output_data* od, Address address)
1989   { this->add(od, Output_reloc_type(type, od, address, true)); }
1990
1991   void
1992   add_relative(unsigned int type, Output_data* od,
1993                Sized_relobj<size, big_endian>* relobj,
1994                unsigned int shndx, Address address)
1995   { this->add(od, Output_reloc_type(type, relobj, shndx, address, true)); }
1996
1997   // Add a target specific relocation.  A target which calls this must
1998   // define the reloc_symbol_index and reloc_addend virtual functions.
1999
2000   void
2001   add_target_specific(unsigned int type, void* arg, Output_data* od,
2002                       Address address)
2003   { this->add(od, Output_reloc_type(type, arg, od, address)); }
2004
2005   void
2006   add_target_specific(unsigned int type, void* arg, Output_data* od,
2007                       Sized_relobj<size, big_endian>* relobj,
2008                       unsigned int shndx, Address address)
2009   { this->add(od, Output_reloc_type(type, arg, relobj, shndx, address)); }
2010 };
2011
2012 // The SHT_RELA version of Output_data_reloc.
2013
2014 template<bool dynamic, int size, bool big_endian>
2015 class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
2016   : public Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size, big_endian>
2017 {
2018  private:
2019   typedef Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size,
2020                                  big_endian> Base;
2021
2022  public:
2023   typedef typename Base::Output_reloc_type Output_reloc_type;
2024   typedef typename Output_reloc_type::Address Address;
2025   typedef typename Output_reloc_type::Addend Addend;
2026
2027   Output_data_reloc(bool sr)
2028     : Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size, big_endian>(sr)
2029   { }
2030
2031   // Add a reloc against a global symbol.
2032
2033   void
2034   add_global(Symbol* gsym, unsigned int type, Output_data* od,
2035              Address address, Addend addend)
2036   {
2037     this->add(od, Output_reloc_type(gsym, type, od, address, addend,
2038                                     false, false, false));
2039   }
2040
2041   void
2042   add_global(Symbol* gsym, unsigned int type, Output_data* od,
2043              Sized_relobj<size, big_endian>* relobj,
2044              unsigned int shndx, Address address,
2045              Addend addend)
2046   {
2047     this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
2048                                     addend, false, false, false));
2049   }
2050
2051   void
2052   add_global_generic(Symbol* gsym, unsigned int type, Output_data* od,
2053                      uint64_t address, uint64_t addend)
2054   {
2055     this->add(od, Output_reloc_type(gsym, type, od,
2056                                     convert_types<Address, uint64_t>(address),
2057                                     convert_types<Addend, uint64_t>(addend),
2058                                     false, false, false));
2059   }
2060
2061   void
2062   add_global_generic(Symbol* gsym, unsigned int type, Output_data* od,
2063                      Relobj* relobj, unsigned int shndx, uint64_t address,
2064                      uint64_t addend)
2065   {
2066     Sized_relobj<size, big_endian>* sized_relobj =
2067       static_cast<Sized_relobj<size, big_endian>*>(relobj);
2068     this->add(od, Output_reloc_type(gsym, type, sized_relobj, shndx,
2069                                     convert_types<Address, uint64_t>(address),
2070                                     convert_types<Addend, uint64_t>(addend),
2071                                     false, false, false));
2072   }
2073
2074   // Add a RELATIVE reloc against a global symbol.  The final output
2075   // relocation will not reference the symbol, but we must keep the symbol
2076   // information long enough to set the addend of the relocation correctly
2077   // when it is written.
2078
2079   void
2080   add_global_relative(Symbol* gsym, unsigned int type, Output_data* od,
2081                       Address address, Addend addend, bool use_plt_offset)
2082   {
2083     this->add(od, Output_reloc_type(gsym, type, od, address, addend, true,
2084                                     true, use_plt_offset));
2085   }
2086
2087   void
2088   add_global_relative(Symbol* gsym, unsigned int type, Output_data* od,
2089                       Sized_relobj<size, big_endian>* relobj,
2090                       unsigned int shndx, Address address, Addend addend,
2091                       bool use_plt_offset)
2092   {
2093     this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
2094                                     addend, true, true, use_plt_offset));
2095   }
2096
2097   // Add a global relocation which does not use a symbol for the relocation,
2098   // but which gets its addend from a symbol.
2099
2100   void
2101   add_symbolless_global_addend(Symbol* gsym, unsigned int type, Output_data* od,
2102                                Address address, Addend addend)
2103   {
2104     this->add(od, Output_reloc_type(gsym, type, od, address, addend,
2105                                     false, true, false));
2106   }
2107
2108   void
2109   add_symbolless_global_addend(Symbol* gsym, unsigned int type,
2110                                Output_data* od,
2111                                Sized_relobj<size, big_endian>* relobj,
2112                                unsigned int shndx, Address address,
2113                                Addend addend)
2114   {
2115     this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
2116                                     addend, false, true, false));
2117   }
2118
2119   // Add a reloc against a local symbol.
2120
2121   void
2122   add_local(Sized_relobj<size, big_endian>* relobj,
2123             unsigned int local_sym_index, unsigned int type,
2124             Output_data* od, Address address, Addend addend)
2125   {
2126     this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, address,
2127                                     addend, false, false, false, false));
2128   }
2129
2130   void
2131   add_local(Sized_relobj<size, big_endian>* relobj,
2132             unsigned int local_sym_index, unsigned int type,
2133             Output_data* od, unsigned int shndx, Address address,
2134             Addend addend)
2135   {
2136     this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
2137                                     address, addend, false, false, false,
2138                                     false));
2139   }
2140
2141   void
2142   add_local_generic(Relobj* relobj, unsigned int local_sym_index,
2143                     unsigned int type, Output_data* od, uint64_t address,
2144                     uint64_t addend)
2145   {
2146     Sized_relobj<size, big_endian>* sized_relobj =
2147       static_cast<Sized_relobj<size, big_endian> *>(relobj);
2148     this->add(od, Output_reloc_type(sized_relobj, local_sym_index, type, od,
2149                                     convert_types<Address, uint64_t>(address),
2150                                     convert_types<Addend, uint64_t>(addend),
2151                                     false, false, false, false));
2152   }
2153
2154   void
2155   add_local_generic(Relobj* relobj, unsigned int local_sym_index,
2156                     unsigned int type, Output_data* od, unsigned int shndx,
2157                     uint64_t address, uint64_t addend)
2158   {
2159     Sized_relobj<size, big_endian>* sized_relobj =
2160       static_cast<Sized_relobj<size, big_endian>*>(relobj);
2161     this->add(od, Output_reloc_type(sized_relobj, local_sym_index, type, shndx,
2162                                     convert_types<Address, uint64_t>(address),
2163                                     convert_types<Addend, uint64_t>(addend),
2164                                     false, false, false, false));
2165   }
2166
2167   // Add a RELATIVE reloc against a local symbol.
2168
2169   void
2170   add_local_relative(Sized_relobj<size, big_endian>* relobj,
2171                      unsigned int local_sym_index, unsigned int type,
2172                      Output_data* od, Address address, Addend addend,
2173                      bool use_plt_offset)
2174   {
2175     this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, address,
2176                                     addend, true, true, false,
2177                                     use_plt_offset));
2178   }
2179
2180   void
2181   add_local_relative(Sized_relobj<size, big_endian>* relobj,
2182                      unsigned int local_sym_index, unsigned int type,
2183                      Output_data* od, unsigned int shndx, Address address,
2184                      Addend addend, bool use_plt_offset)
2185   {
2186     this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
2187                                     address, addend, true, true, false,
2188                                     use_plt_offset));
2189   }
2190
2191   // Add a local relocation which does not use a symbol for the relocation,
2192   // but which gets it's addend from a symbol.
2193
2194   void
2195   add_symbolless_local_addend(Sized_relobj<size, big_endian>* relobj,
2196                               unsigned int local_sym_index, unsigned int type,
2197                               Output_data* od, Address address, Addend addend)
2198   {
2199     this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, address,
2200                                     addend, false, true, false, false));
2201   }
2202
2203   void
2204   add_symbolless_local_addend(Sized_relobj<size, big_endian>* relobj,
2205                               unsigned int local_sym_index, unsigned int type,
2206                               Output_data* od, unsigned int shndx,
2207                               Address address, Addend addend)
2208   {
2209     this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
2210                                     address, addend, false, true, false,
2211                                     false));
2212   }
2213
2214   // Add a reloc against a local section symbol.  This will be
2215   // converted into a reloc against the STT_SECTION symbol of the
2216   // output section.
2217
2218   void
2219   add_local_section(Sized_relobj<size, big_endian>* relobj,
2220                     unsigned int input_shndx, unsigned int type,
2221                     Output_data* od, Address address, Addend addend)
2222   {
2223     this->add(od, Output_reloc_type(relobj, input_shndx, type, od, address,
2224                                     addend, false, false, true, false));
2225   }
2226
2227   void
2228   add_local_section(Sized_relobj<size, big_endian>* relobj,
2229                     unsigned int input_shndx, unsigned int type,
2230                     Output_data* od, unsigned int shndx, Address address,
2231                     Addend addend)
2232   {
2233     this->add(od, Output_reloc_type(relobj, input_shndx, type, shndx,
2234                                     address, addend, false, false, true,
2235                                     false));
2236   }
2237
2238   // A reloc against the STT_SECTION symbol of an output section.
2239
2240   void
2241   add_output_section(Output_section* os, unsigned int type, Output_data* od,
2242                      Address address, Addend addend)
2243   { this->add(od, Output_reloc_type(os, type, od, address, addend, false)); }
2244
2245   void
2246   add_output_section(Output_section* os, unsigned int type, Output_data* od,
2247                      Sized_relobj<size, big_endian>* relobj,
2248                      unsigned int shndx, Address address, Addend addend)
2249   {
2250     this->add(od, Output_reloc_type(os, type, relobj, shndx, address,
2251                                     addend, false));
2252   }
2253
2254   void
2255   add_output_section_generic(Output_section* os, unsigned int type,
2256                              Output_data* od, uint64_t address,
2257                              uint64_t addend)
2258   {
2259     this->add(od, Output_reloc_type(os, type, od,
2260                                     convert_types<Address, uint64_t>(address),
2261                                     convert_types<Addend, uint64_t>(addend),
2262                                     false));
2263   }
2264
2265   void
2266   add_output_section_generic(Output_section* os, unsigned int type,
2267                              Output_data* od, Relobj* relobj,
2268                              unsigned int shndx, uint64_t address,
2269                              uint64_t addend)
2270   {
2271     Sized_relobj<size, big_endian>* sized_relobj =
2272       static_cast<Sized_relobj<size, big_endian>*>(relobj);
2273     this->add(od, Output_reloc_type(os, type, sized_relobj, shndx,
2274                                     convert_types<Address, uint64_t>(address),
2275                                     convert_types<Addend, uint64_t>(addend),
2276                                     false));
2277   }
2278
2279   // As above, but the reloc TYPE is relative
2280
2281   void
2282   add_output_section_relative(Output_section* os, unsigned int type,
2283                               Output_data* od, Address address, Addend addend)
2284   { this->add(od, Output_reloc_type(os, type, od, address, addend, true)); }
2285
2286   void
2287   add_output_section_relative(Output_section* os, unsigned int type,
2288                               Output_data* od,
2289                               Sized_relobj<size, big_endian>* relobj,
2290                               unsigned int shndx, Address address,
2291                               Addend addend)
2292   {
2293     this->add(od, Output_reloc_type(os, type, relobj, shndx,
2294                                     address, addend, true));
2295   }
2296
2297   // Add an absolute relocation.
2298
2299   void
2300   add_absolute(unsigned int type, Output_data* od, Address address,
2301                Addend addend)
2302   { this->add(od, Output_reloc_type(type, od, address, addend, false)); }
2303
2304   void
2305   add_absolute(unsigned int type, Output_data* od,
2306                Sized_relobj<size, big_endian>* relobj,
2307                unsigned int shndx, Address address, Addend addend)
2308   {
2309     this->add(od, Output_reloc_type(type, relobj, shndx, address, addend,
2310                                     false));
2311   }
2312
2313   // Add a relative relocation
2314
2315   void
2316   add_relative(unsigned int type, Output_data* od, Address address,
2317                Addend addend)
2318   { this->add(od, Output_reloc_type(type, od, address, addend, true)); }
2319
2320   void
2321   add_relative(unsigned int type, Output_data* od,
2322                Sized_relobj<size, big_endian>* relobj,
2323                unsigned int shndx, Address address, Addend addend)
2324   {
2325     this->add(od, Output_reloc_type(type, relobj, shndx, address, addend,
2326                                     true));
2327   }
2328
2329   // Add a target specific relocation.  A target which calls this must
2330   // define the reloc_symbol_index and reloc_addend virtual functions.
2331
2332   void
2333   add_target_specific(unsigned int type, void* arg, Output_data* od,
2334                       Address address, Addend addend)
2335   { this->add(od, Output_reloc_type(type, arg, od, address, addend)); }
2336
2337   void
2338   add_target_specific(unsigned int type, void* arg, Output_data* od,
2339                       Sized_relobj<size, big_endian>* relobj,
2340                       unsigned int shndx, Address address, Addend addend)
2341   {
2342     this->add(od, Output_reloc_type(type, arg, relobj, shndx, address,
2343                                     addend));
2344   }
2345 };
2346
2347 // Output_relocatable_relocs represents a relocation section in a
2348 // relocatable link.  The actual data is written out in the target
2349 // hook relocate_relocs.  This just saves space for it.
2350
2351 template<int sh_type, int size, bool big_endian>
2352 class Output_relocatable_relocs : public Output_section_data
2353 {
2354  public:
2355   Output_relocatable_relocs(Relocatable_relocs* rr)
2356     : Output_section_data(Output_data::default_alignment_for_size(size)),
2357       rr_(rr)
2358   { }
2359
2360   void
2361   set_final_data_size();
2362
2363   // Write out the data.  There is nothing to do here.
2364   void
2365   do_write(Output_file*)
2366   { }
2367
2368   // Write to a map file.
2369   void
2370   do_print_to_mapfile(Mapfile* mapfile) const
2371   { mapfile->print_output_data(this, _("** relocs")); }
2372
2373  private:
2374   // The relocs associated with this input section.
2375   Relocatable_relocs* rr_;
2376 };
2377
2378 // Handle a GROUP section.
2379
2380 template<int size, bool big_endian>
2381 class Output_data_group : public Output_section_data
2382 {
2383  public:
2384   // The constructor clears *INPUT_SHNDXES.
2385   Output_data_group(Sized_relobj_file<size, big_endian>* relobj,
2386                     section_size_type entry_count,
2387                     elfcpp::Elf_Word flags,
2388                     std::vector<unsigned int>* input_shndxes);
2389
2390   void
2391   do_write(Output_file*);
2392
2393   // Write to a map file.
2394   void
2395   do_print_to_mapfile(Mapfile* mapfile) const
2396   { mapfile->print_output_data(this, _("** group")); }
2397
2398   // Set final data size.
2399   void
2400   set_final_data_size()
2401   { this->set_data_size((this->input_shndxes_.size() + 1) * 4); }
2402
2403  private:
2404   // The input object.
2405   Sized_relobj_file<size, big_endian>* relobj_;
2406   // The group flag word.
2407   elfcpp::Elf_Word flags_;
2408   // The section indexes of the input sections in this group.
2409   std::vector<unsigned int> input_shndxes_;
2410 };
2411
2412 // Output_data_got is used to manage a GOT.  Each entry in the GOT is
2413 // for one symbol--either a global symbol or a local symbol in an
2414 // object.  The target specific code adds entries to the GOT as
2415 // needed.  The GOT_SIZE template parameter is the size in bits of a
2416 // GOT entry, typically 32 or 64.
2417
2418 class Output_data_got_base : public Output_section_data_build
2419 {
2420  public:
2421   Output_data_got_base(uint64_t align)
2422     : Output_section_data_build(align)
2423   { }
2424
2425   Output_data_got_base(off_t data_size, uint64_t align)
2426     : Output_section_data_build(data_size, align)
2427   { }
2428
2429   // Reserve the slot at index I in the GOT.
2430   void
2431   reserve_slot(unsigned int i)
2432   { this->do_reserve_slot(i); }
2433
2434  protected:
2435   // Reserve the slot at index I in the GOT.
2436   virtual void
2437   do_reserve_slot(unsigned int i) = 0;
2438 };
2439
2440 template<int got_size, bool big_endian>
2441 class Output_data_got : public Output_data_got_base
2442 {
2443  public:
2444   typedef typename elfcpp::Elf_types<got_size>::Elf_Addr Valtype;
2445
2446   Output_data_got()
2447     : Output_data_got_base(Output_data::default_alignment_for_size(got_size)),
2448       entries_(), free_list_()
2449   { }
2450
2451   Output_data_got(off_t data_size)
2452     : Output_data_got_base(data_size,
2453                            Output_data::default_alignment_for_size(got_size)),
2454       entries_(), free_list_()
2455   {
2456     // For an incremental update, we have an existing GOT section.
2457     // Initialize the list of entries and the free list.
2458     this->entries_.resize(data_size / (got_size / 8));
2459     this->free_list_.init(data_size, false);
2460   }
2461
2462   // Add an entry for a global symbol to the GOT.  Return true if this
2463   // is a new GOT entry, false if the symbol was already in the GOT.
2464   bool
2465   add_global(Symbol* gsym, unsigned int got_type);
2466
2467   // Like add_global, but use the PLT offset of the global symbol if
2468   // it has one.
2469   bool
2470   add_global_plt(Symbol* gsym, unsigned int got_type);
2471
2472   // Like add_global, but for a TLS symbol where the value will be
2473   // offset using Target::tls_offset_for_global.
2474   bool
2475   add_global_tls(Symbol* gsym, unsigned int got_type)
2476   { return add_global_plt(gsym, got_type); }
2477
2478   // Add an entry for a global symbol to the GOT, and add a dynamic
2479   // relocation of type R_TYPE for the GOT entry.
2480   void
2481   add_global_with_rel(Symbol* gsym, unsigned int got_type,
2482                       Output_data_reloc_generic* rel_dyn, unsigned int r_type);
2483
2484   // Add a pair of entries for a global symbol to the GOT, and add
2485   // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
2486   void
2487   add_global_pair_with_rel(Symbol* gsym, unsigned int got_type,
2488                            Output_data_reloc_generic* rel_dyn,
2489                            unsigned int r_type_1, unsigned int r_type_2);
2490
2491   // Add an entry for a local symbol to the GOT.  This returns true if
2492   // this is a new GOT entry, false if the symbol already has a GOT
2493   // entry.
2494   bool
2495   add_local(Relobj* object, unsigned int sym_index, unsigned int got_type);
2496
2497   // Add an entry for a local symbol plus ADDEND to the GOT.  This returns
2498   // true if this is a new GOT entry, false if the symbol already has a GOT
2499   // entry.
2500   bool
2501   add_local(Relobj* object, unsigned int sym_index, unsigned int got_type,
2502             uint64_t addend);
2503
2504   // Like add_local, but use the PLT offset of the local symbol if it
2505   // has one.
2506   bool
2507   add_local_plt(Relobj* object, unsigned int sym_index, unsigned int got_type);
2508
2509   // Like add_local, but for a TLS symbol where the value will be
2510   // offset using Target::tls_offset_for_local.
2511   bool
2512   add_local_tls(Relobj* object, unsigned int sym_index, unsigned int got_type)
2513   { return add_local_plt(object, sym_index, got_type); }
2514
2515   // Add an entry for a local symbol to the GOT, and add a dynamic
2516   // relocation of type R_TYPE for the GOT entry.
2517   void
2518   add_local_with_rel(Relobj* object, unsigned int sym_index,
2519                      unsigned int got_type, Output_data_reloc_generic* rel_dyn,
2520                      unsigned int r_type);
2521
2522   // Add an entry for a local symbol plus ADDEND to the GOT, and add a dynamic
2523   // relocation of type R_TYPE for the GOT entry.
2524   void
2525   add_local_with_rel(Relobj* object, unsigned int sym_index,
2526                      unsigned int got_type, Output_data_reloc_generic* rel_dyn,
2527                      unsigned int r_type, uint64_t addend);
2528
2529   // Add a pair of entries for a local symbol to the GOT, and add
2530   // a dynamic relocation of type R_TYPE using the section symbol of
2531   // the output section to which input section SHNDX maps, on the first.
2532   // The first got entry will have a value of zero, the second the
2533   // value of the local symbol.
2534   void
2535   add_local_pair_with_rel(Relobj* object, unsigned int sym_index,
2536                           unsigned int shndx, unsigned int got_type,
2537                           Output_data_reloc_generic* rel_dyn,
2538                           unsigned int r_type);
2539
2540   // Add a pair of entries for a local symbol plus ADDEND to the GOT, and add
2541   // a dynamic relocation of type R_TYPE using the section symbol of
2542   // the output section to which input section SHNDX maps, on the first.
2543   // The first got entry will have a value of zero, the second the
2544   // value of the local symbol.
2545   void
2546   add_local_pair_with_rel(Relobj* object, unsigned int sym_index,
2547                           unsigned int shndx, unsigned int got_type,
2548                           Output_data_reloc_generic* rel_dyn,
2549                           unsigned int r_type, uint64_t addend);
2550
2551   // Add a pair of entries for a local symbol to the GOT, and add
2552   // a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
2553   // The first got entry will have a value of zero, the second the
2554   // value of the local symbol offset by Target::tls_offset_for_local.
2555   void
2556   add_local_tls_pair(Relobj* object, unsigned int sym_index,
2557                      unsigned int got_type,
2558                      Output_data_reloc_generic* rel_dyn,
2559                      unsigned int r_type);
2560
2561   // Add a constant to the GOT.  This returns the offset of the new
2562   // entry from the start of the GOT.
2563   unsigned int
2564   add_constant(Valtype constant)
2565   { return this->add_got_entry(Got_entry(constant)); }
2566
2567   // Add a pair of constants to the GOT.  This returns the offset of
2568   // the new entry from the start of the GOT.
2569   unsigned int
2570   add_constant_pair(Valtype c1, Valtype c2)
2571   { return this->add_got_entry_pair(Got_entry(c1), Got_entry(c2)); }
2572
2573   // Replace GOT entry I with a new constant.
2574   void
2575   replace_constant(unsigned int i, Valtype constant)
2576   {
2577     this->replace_got_entry(i, Got_entry(constant));
2578   }
2579
2580   // Reserve a slot in the GOT for a local symbol.
2581   void
2582   reserve_local(unsigned int i, Relobj* object, unsigned int sym_index,
2583                 unsigned int got_type);
2584
2585   // Reserve a slot in the GOT for a global symbol.
2586   void
2587   reserve_global(unsigned int i, Symbol* gsym, unsigned int got_type);
2588
2589  protected:
2590   // Write out the GOT table.
2591   void
2592   do_write(Output_file*);
2593
2594   // Write to a map file.
2595   void
2596   do_print_to_mapfile(Mapfile* mapfile) const
2597   { mapfile->print_output_data(this, _("** GOT")); }
2598
2599   // Reserve the slot at index I in the GOT.
2600   virtual void
2601   do_reserve_slot(unsigned int i)
2602   { this->free_list_.remove(i * got_size / 8, (i + 1) * got_size / 8); }
2603
2604   // Return the number of words in the GOT.
2605   unsigned int
2606   num_entries () const
2607   { return this->entries_.size(); }
2608
2609   // Return the offset into the GOT of GOT entry I.
2610   unsigned int
2611   got_offset(unsigned int i) const
2612   { return i * (got_size / 8); }
2613
2614  private:
2615   // This POD class holds a single GOT entry.
2616   class Got_entry
2617   {
2618    public:
2619     // Create a zero entry.
2620     Got_entry()
2621       : local_sym_index_(RESERVED_CODE), use_plt_or_tls_offset_(false),
2622         addend_(0)
2623     { this->u_.constant = 0; }
2624
2625     // Create a global symbol entry.
2626     Got_entry(Symbol* gsym, bool use_plt_or_tls_offset)
2627       : local_sym_index_(GSYM_CODE),
2628         use_plt_or_tls_offset_(use_plt_or_tls_offset), addend_(0)
2629     { this->u_.gsym = gsym; }
2630
2631     // Create a local symbol entry.
2632     Got_entry(Relobj* object, unsigned int local_sym_index,
2633               bool use_plt_or_tls_offset)
2634       : local_sym_index_(local_sym_index),
2635         use_plt_or_tls_offset_(use_plt_or_tls_offset), addend_(0)
2636     {
2637       gold_assert(local_sym_index != GSYM_CODE
2638                   && local_sym_index != CONSTANT_CODE
2639                   && local_sym_index != RESERVED_CODE
2640                   && local_sym_index == this->local_sym_index_);
2641       this->u_.object = object;
2642     }
2643
2644     // Create a local symbol entry plus addend.
2645     Got_entry(Relobj* object, unsigned int local_sym_index,
2646         bool use_plt_or_tls_offset, uint64_t addend)
2647       : local_sym_index_(local_sym_index),
2648         use_plt_or_tls_offset_(use_plt_or_tls_offset), addend_(addend)
2649     {
2650       gold_assert(local_sym_index != GSYM_CODE
2651       && local_sym_index != CONSTANT_CODE
2652       && local_sym_index != RESERVED_CODE
2653       && local_sym_index == this->local_sym_index_);
2654       this->u_.object = object;
2655     }
2656
2657     // Create a constant entry.  The constant is a host value--it will
2658     // be swapped, if necessary, when it is written out.
2659     explicit Got_entry(Valtype constant)
2660       : local_sym_index_(CONSTANT_CODE), use_plt_or_tls_offset_(false)
2661     { this->u_.constant = constant; }
2662
2663     // Write the GOT entry to an output view.
2664     void
2665     write(unsigned int got_indx, unsigned char* pov) const;
2666
2667    private:
2668     enum
2669     {
2670       GSYM_CODE = 0x7fffffff,
2671       CONSTANT_CODE = 0x7ffffffe,
2672       RESERVED_CODE = 0x7ffffffd
2673     };
2674
2675     union
2676     {
2677       // For a local symbol, the object.
2678       Relobj* object;
2679       // For a global symbol, the symbol.
2680       Symbol* gsym;
2681       // For a constant, the constant.
2682       Valtype constant;
2683     } u_;
2684     // For a local symbol, the local symbol index.  This is GSYM_CODE
2685     // for a global symbol, or CONSTANT_CODE for a constant.
2686     unsigned int local_sym_index_ : 31;
2687     // Whether to use the PLT offset of the symbol if it has one.
2688     // For TLS symbols, whether to offset the symbol value.
2689     bool use_plt_or_tls_offset_ : 1;
2690     // The addend.
2691     uint64_t addend_;
2692   };
2693
2694   typedef std::vector<Got_entry> Got_entries;
2695
2696   // Create a new GOT entry and return its offset.
2697   unsigned int
2698   add_got_entry(Got_entry got_entry);
2699
2700   // Create a pair of new GOT entries and return the offset of the first.
2701   unsigned int
2702   add_got_entry_pair(Got_entry got_entry_1, Got_entry got_entry_2);
2703
2704   // Replace GOT entry I with a new value.
2705   void
2706   replace_got_entry(unsigned int i, Got_entry got_entry);
2707
2708   // Return the offset into the GOT of the last entry added.
2709   unsigned int
2710   last_got_offset() const
2711   { return this->got_offset(this->num_entries() - 1); }
2712
2713   // Set the size of the section.
2714   void
2715   set_got_size()
2716   { this->set_current_data_size(this->got_offset(this->num_entries())); }
2717
2718   // The list of GOT entries.
2719   Got_entries entries_;
2720
2721   // List of available regions within the section, for incremental
2722   // update links.
2723   Free_list free_list_;
2724 };
2725
2726 // Output_data_dynamic is used to hold the data in SHT_DYNAMIC
2727 // section.
2728
2729 class Output_data_dynamic : public Output_section_data
2730 {
2731  public:
2732   Output_data_dynamic(Stringpool* pool)
2733     : Output_section_data(Output_data::default_alignment()),
2734       entries_(), pool_(pool)
2735   { }
2736
2737   // Add a new dynamic entry with a fixed numeric value.
2738   void
2739   add_constant(elfcpp::DT tag, unsigned int val)
2740   { this->add_entry(Dynamic_entry(tag, val)); }
2741
2742   // Add a new dynamic entry with the address of output data.
2743   void
2744   add_section_address(elfcpp::DT tag, const Output_data* od)
2745   { this->add_entry(Dynamic_entry(tag, od, false)); }
2746
2747   // Add a new dynamic entry with the address of output data
2748   // plus a constant offset.
2749   void
2750   add_section_plus_offset(elfcpp::DT tag, const Output_data* od,
2751                           unsigned int offset)
2752   { this->add_entry(Dynamic_entry(tag, od, offset)); }
2753
2754   // Add a new dynamic entry with the size of output data.
2755   void
2756   add_section_size(elfcpp::DT tag, const Output_data* od)
2757   { this->add_entry(Dynamic_entry(tag, od, true)); }
2758
2759   // Add a new dynamic entry with the total size of two output datas.
2760   void
2761   add_section_size(elfcpp::DT tag, const Output_data* od,
2762                    const Output_data* od2)
2763   { this->add_entry(Dynamic_entry(tag, od, od2)); }
2764
2765   // Add a new dynamic entry with the address of a symbol.
2766   void
2767   add_symbol(elfcpp::DT tag, const Symbol* sym)
2768   { this->add_entry(Dynamic_entry(tag, sym)); }
2769
2770   // Add a new dynamic entry with a string.
2771   void
2772   add_string(elfcpp::DT tag, const char* str)
2773   { this->add_entry(Dynamic_entry(tag, this->pool_->add(str, true, NULL))); }
2774
2775   void
2776   add_string(elfcpp::DT tag, const std::string& str)
2777   { this->add_string(tag, str.c_str()); }
2778
2779   // Add a new dynamic entry with custom value.
2780   void
2781   add_custom(elfcpp::DT tag)
2782   { this->add_entry(Dynamic_entry(tag)); }
2783
2784   // Get a dynamic entry offset.
2785   unsigned int
2786   get_entry_offset(elfcpp::DT tag) const;
2787
2788  protected:
2789   // Adjust the output section to set the entry size.
2790   void
2791   do_adjust_output_section(Output_section*);
2792
2793   // Set the final data size.
2794   void
2795   set_final_data_size();
2796
2797   // Write out the dynamic entries.
2798   void
2799   do_write(Output_file*);
2800
2801   // Write to a map file.
2802   void
2803   do_print_to_mapfile(Mapfile* mapfile) const
2804   { mapfile->print_output_data(this, _("** dynamic")); }
2805
2806  private:
2807   // This POD class holds a single dynamic entry.
2808   class Dynamic_entry
2809   {
2810    public:
2811     // Create an entry with a fixed numeric value.
2812     Dynamic_entry(elfcpp::DT tag, unsigned int val)
2813       : tag_(tag), offset_(DYNAMIC_NUMBER)
2814     { this->u_.val = val; }
2815
2816     // Create an entry with the size or address of a section.
2817     Dynamic_entry(elfcpp::DT tag, const Output_data* od, bool section_size)
2818       : tag_(tag),
2819         offset_(section_size
2820                 ? DYNAMIC_SECTION_SIZE
2821                 : DYNAMIC_SECTION_ADDRESS)
2822     {
2823       this->u_.od = od;
2824       this->od2 = NULL;
2825     }
2826
2827     // Create an entry with the size of two sections.
2828     Dynamic_entry(elfcpp::DT tag, const Output_data* od, const Output_data* od2)
2829       : tag_(tag),
2830         offset_(DYNAMIC_SECTION_SIZE)
2831     {
2832       this->u_.od = od;
2833       this->od2 = od2;
2834     }
2835
2836     // Create an entry with the address of a section plus a constant offset.
2837     Dynamic_entry(elfcpp::DT tag, const Output_data* od, unsigned int offset)
2838       : tag_(tag),
2839         offset_(offset)
2840     { this->u_.od = od; }
2841
2842     // Create an entry with the address of a symbol.
2843     Dynamic_entry(elfcpp::DT tag, const Symbol* sym)
2844       : tag_(tag), offset_(DYNAMIC_SYMBOL)
2845     { this->u_.sym = sym; }
2846
2847     // Create an entry with a string.
2848     Dynamic_entry(elfcpp::DT tag, const char* str)
2849       : tag_(tag), offset_(DYNAMIC_STRING)
2850     { this->u_.str = str; }
2851
2852     // Create an entry with a custom value.
2853     Dynamic_entry(elfcpp::DT tag)
2854       : tag_(tag), offset_(DYNAMIC_CUSTOM)
2855     { }
2856
2857     // Return the tag of this entry.
2858     elfcpp::DT
2859     tag() const
2860     { return this->tag_; }
2861
2862     // Write the dynamic entry to an output view.
2863     template<int size, bool big_endian>
2864     void
2865     write(unsigned char* pov, const Stringpool*) const;
2866
2867    private:
2868     // Classification is encoded in the OFFSET field.
2869     enum Classification
2870     {
2871       // Section address.
2872       DYNAMIC_SECTION_ADDRESS = 0,
2873       // Number.
2874       DYNAMIC_NUMBER = -1U,
2875       // Section size.
2876       DYNAMIC_SECTION_SIZE = -2U,
2877       // Symbol address.
2878       DYNAMIC_SYMBOL = -3U,
2879       // String.
2880       DYNAMIC_STRING = -4U,
2881       // Custom value.
2882       DYNAMIC_CUSTOM = -5U
2883       // Any other value indicates a section address plus OFFSET.
2884     };
2885
2886     union
2887     {
2888       // For DYNAMIC_NUMBER.
2889       unsigned int val;
2890       // For DYNAMIC_SECTION_SIZE and section address plus OFFSET.
2891       const Output_data* od;
2892       // For DYNAMIC_SYMBOL.
2893       const Symbol* sym;
2894       // For DYNAMIC_STRING.
2895       const char* str;
2896     } u_;
2897     // For DYNAMIC_SYMBOL with two sections.
2898     const Output_data* od2;
2899     // The dynamic tag.
2900     elfcpp::DT tag_;
2901     // The type of entry (Classification) or offset within a section.
2902     unsigned int offset_;
2903   };
2904
2905   // Add an entry to the list.
2906   void
2907   add_entry(const Dynamic_entry& entry)
2908   { this->entries_.push_back(entry); }
2909
2910   // Sized version of write function.
2911   template<int size, bool big_endian>
2912   void
2913   sized_write(Output_file* of);
2914
2915   // The type of the list of entries.
2916   typedef std::vector<Dynamic_entry> Dynamic_entries;
2917
2918   // The entries.
2919   Dynamic_entries entries_;
2920   // The pool used for strings.
2921   Stringpool* pool_;
2922 };
2923
2924 // Output_symtab_xindex is used to handle SHT_SYMTAB_SHNDX sections,
2925 // which may be required if the object file has more than
2926 // SHN_LORESERVE sections.
2927
2928 class Output_symtab_xindex : public Output_section_data
2929 {
2930  public:
2931   Output_symtab_xindex(size_t symcount)
2932     : Output_section_data(symcount * 4, 4, true),
2933       entries_()
2934   { }
2935
2936   // Add an entry: symbol number SYMNDX has section SHNDX.
2937   void
2938   add(unsigned int symndx, unsigned int shndx)
2939   { this->entries_.push_back(std::make_pair(symndx, shndx)); }
2940
2941  protected:
2942   void
2943   do_write(Output_file*);
2944
2945   // Write to a map file.
2946   void
2947   do_print_to_mapfile(Mapfile* mapfile) const
2948   { mapfile->print_output_data(this, _("** symtab xindex")); }
2949
2950  private:
2951   template<bool big_endian>
2952   void
2953   endian_do_write(unsigned char*);
2954
2955   // It is likely that most symbols will not require entries.  Rather
2956   // than keep a vector for all symbols, we keep pairs of symbol index
2957   // and section index.
2958   typedef std::vector<std::pair<unsigned int, unsigned int> > Xindex_entries;
2959
2960   // The entries we need.
2961   Xindex_entries entries_;
2962 };
2963
2964 // A relaxed input section.
2965 class Output_relaxed_input_section : public Output_section_data_build
2966 {
2967  public:
2968   // We would like to call relobj->section_addralign(shndx) to get the
2969   // alignment but we do not want the constructor to fail.  So callers
2970   // are repsonsible for ensuring that.
2971   Output_relaxed_input_section(Relobj* relobj, unsigned int shndx,
2972                                uint64_t addralign)
2973     : Output_section_data_build(addralign), relobj_(relobj), shndx_(shndx)
2974   { }
2975
2976   // Return the Relobj of this relaxed input section.
2977   Relobj*
2978   relobj() const
2979   { return this->relobj_; }
2980
2981   // Return the section index of this relaxed input section.
2982   unsigned int
2983   shndx() const
2984   { return this->shndx_; }
2985
2986  protected:
2987   void
2988   set_relobj(Relobj* relobj)
2989   { this->relobj_ = relobj; }
2990
2991   void
2992   set_shndx(unsigned int shndx)
2993   { this->shndx_ = shndx; }
2994
2995  private:
2996   Relobj* relobj_;
2997   unsigned int shndx_;
2998 };
2999
3000 // This class describes properties of merge data sections.  It is used
3001 // as a key type for maps.
3002 class Merge_section_properties
3003 {
3004  public:
3005   Merge_section_properties(bool is_string, uint64_t entsize,
3006                              uint64_t addralign)
3007     : is_string_(is_string), entsize_(entsize), addralign_(addralign)
3008   { }
3009
3010   // Whether this equals to another Merge_section_properties MSP.
3011   bool
3012   eq(const Merge_section_properties& msp) const
3013   {
3014     return ((this->is_string_ == msp.is_string_)
3015             && (this->entsize_ == msp.entsize_)
3016             && (this->addralign_ == msp.addralign_));
3017   }
3018
3019   // Compute a hash value for this using 64-bit FNV-1a hash.
3020   size_t
3021   hash_value() const
3022   {
3023     uint64_t h = 14695981039346656037ULL;       // FNV offset basis.
3024     uint64_t prime = 1099511628211ULL;
3025     h = (h ^ static_cast<uint64_t>(this->is_string_)) * prime;
3026     h = (h ^ static_cast<uint64_t>(this->entsize_)) * prime;
3027     h = (h ^ static_cast<uint64_t>(this->addralign_)) * prime;
3028     return h;
3029   }
3030
3031   // Functors for associative containers.
3032   struct equal_to
3033   {
3034     bool
3035     operator()(const Merge_section_properties& msp1,
3036                const Merge_section_properties& msp2) const
3037     { return msp1.eq(msp2); }
3038   };
3039
3040   struct hash
3041   {
3042     size_t
3043     operator()(const Merge_section_properties& msp) const
3044     { return msp.hash_value(); }
3045   };
3046
3047  private:
3048   // Whether this merge data section is for strings.
3049   bool is_string_;
3050   // Entsize of this merge data section.
3051   uint64_t entsize_;
3052   // Address alignment.
3053   uint64_t addralign_;
3054 };
3055
3056 // This class is used to speed up look up of special input sections in an
3057 // Output_section.
3058
3059 class Output_section_lookup_maps
3060 {
3061  public:
3062   Output_section_lookup_maps()
3063     : is_valid_(true), merge_sections_by_properties_(),
3064       relaxed_input_sections_by_id_()
3065   { }
3066
3067   // Whether the maps are valid.
3068   bool
3069   is_valid() const
3070   { return this->is_valid_; }
3071
3072   // Invalidate the maps.
3073   void
3074   invalidate()
3075   { this->is_valid_ = false; }
3076
3077   // Clear the maps.
3078   void
3079   clear()
3080   {
3081     this->merge_sections_by_properties_.clear();
3082     this->relaxed_input_sections_by_id_.clear();
3083     // A cleared map is valid.
3084     this->is_valid_ = true;
3085   }
3086
3087   // Find a merge section by merge section properties.  Return NULL if none
3088   // is found.
3089   Output_merge_base*
3090   find_merge_section(const Merge_section_properties& msp) const
3091   {
3092     gold_assert(this->is_valid_);
3093     Merge_sections_by_properties::const_iterator p =
3094       this->merge_sections_by_properties_.find(msp);
3095     return p != this->merge_sections_by_properties_.end() ? p->second : NULL;
3096   }
3097
3098   // Add a merge section pointed by POMB with properties MSP.
3099   void
3100   add_merge_section(const Merge_section_properties& msp,
3101                     Output_merge_base* pomb)
3102   {
3103     std::pair<Merge_section_properties, Output_merge_base*> value(msp, pomb);
3104     std::pair<Merge_sections_by_properties::iterator, bool> result =
3105       this->merge_sections_by_properties_.insert(value);
3106     gold_assert(result.second);
3107   }
3108
3109   // Find a relaxed input section of OBJECT with index SHNDX.
3110   Output_relaxed_input_section*
3111   find_relaxed_input_section(const Relobj* object, unsigned int shndx) const
3112   {
3113     gold_assert(this->is_valid_);
3114     Relaxed_input_sections_by_id::const_iterator p =
3115       this->relaxed_input_sections_by_id_.find(Const_section_id(object, shndx));
3116     return p != this->relaxed_input_sections_by_id_.end() ? p->second : NULL;
3117   }
3118
3119   // Add a relaxed input section pointed by POMB and whose original input
3120   // section is in OBJECT with index SHNDX.
3121   void
3122   add_relaxed_input_section(const Relobj* relobj, unsigned int shndx,
3123                             Output_relaxed_input_section* poris)
3124   {
3125     Const_section_id csid(relobj, shndx);
3126     std::pair<Const_section_id, Output_relaxed_input_section*>
3127       value(csid, poris);
3128     std::pair<Relaxed_input_sections_by_id::iterator, bool> result =
3129       this->relaxed_input_sections_by_id_.insert(value);
3130     gold_assert(result.second);
3131   }
3132
3133  private:
3134   typedef Unordered_map<Merge_section_properties, Output_merge_base*,
3135                         Merge_section_properties::hash,
3136                         Merge_section_properties::equal_to>
3137     Merge_sections_by_properties;
3138
3139   typedef Unordered_map<Const_section_id, Output_relaxed_input_section*,
3140                         Const_section_id_hash>
3141     Relaxed_input_sections_by_id;
3142
3143   // Whether this is valid
3144   bool is_valid_;
3145   // Merge sections by merge section properties.
3146   Merge_sections_by_properties merge_sections_by_properties_;
3147   // Relaxed sections by section IDs.
3148   Relaxed_input_sections_by_id relaxed_input_sections_by_id_;
3149 };
3150
3151 // This abstract base class defines the interface for the
3152 // types of methods used to fill free space left in an output
3153 // section during an incremental link.  These methods are used
3154 // to insert dummy compilation units into debug info so that
3155 // debug info consumers can scan the debug info serially.
3156
3157 class Output_fill
3158 {
3159  public:
3160   Output_fill()
3161     : is_big_endian_(parameters->target().is_big_endian())
3162   { }
3163
3164   virtual
3165   ~Output_fill()
3166   { }
3167
3168   // Return the smallest size chunk of free space that can be
3169   // filled with a dummy compilation unit.
3170   size_t
3171   minimum_hole_size() const
3172   { return this->do_minimum_hole_size(); }
3173
3174   // Write a fill pattern of length LEN at offset OFF in the file.
3175   void
3176   write(Output_file* of, off_t off, size_t len) const
3177   { this->do_write(of, off, len); }
3178
3179  protected:
3180   virtual size_t
3181   do_minimum_hole_size() const = 0;
3182
3183   virtual void
3184   do_write(Output_file* of, off_t off, size_t len) const = 0;
3185
3186   bool
3187   is_big_endian() const
3188   { return this->is_big_endian_; }
3189
3190  private:
3191   bool is_big_endian_;
3192 };
3193
3194 // Fill method that introduces a dummy compilation unit in
3195 // a .debug_info or .debug_types section.
3196
3197 class Output_fill_debug_info : public Output_fill
3198 {
3199  public:
3200   Output_fill_debug_info(bool is_debug_types)
3201     : is_debug_types_(is_debug_types)
3202   { }
3203
3204  protected:
3205   virtual size_t
3206   do_minimum_hole_size() const;
3207
3208   virtual void
3209   do_write(Output_file* of, off_t off, size_t len) const;
3210
3211  private:
3212   // Version of the header.
3213   static const int version = 4;
3214   // True if this is a .debug_types section.
3215   bool is_debug_types_;
3216 };
3217
3218 // Fill method that introduces a dummy compilation unit in
3219 // a .debug_line section.
3220
3221 class Output_fill_debug_line : public Output_fill
3222 {
3223  public:
3224   Output_fill_debug_line()
3225   { }
3226
3227  protected:
3228   virtual size_t
3229   do_minimum_hole_size() const;
3230
3231   virtual void
3232   do_write(Output_file* of, off_t off, size_t len) const;
3233
3234  private:
3235   // Version of the header.  We write a DWARF-3 header because it's smaller
3236   // and many tools have not yet been updated to understand the DWARF-4 header.
3237   static const int version = 3;
3238   // Length of the portion of the header that follows the header_length
3239   // field.  This includes the following fields:
3240   // minimum_instruction_length, default_is_stmt, line_base, line_range,
3241   // opcode_base, standard_opcode_lengths[], include_directories, filenames.
3242   // The standard_opcode_lengths array is 12 bytes long, and the
3243   // include_directories and filenames fields each contain only a single
3244   // null byte.
3245   static const size_t header_length = 19;
3246 };
3247
3248 // An output section.  We don't expect to have too many output
3249 // sections, so we don't bother to do a template on the size.
3250
3251 class Output_section : public Output_data
3252 {
3253  public:
3254   // Create an output section, giving the name, type, and flags.
3255   Output_section(const char* name, elfcpp::Elf_Word, elfcpp::Elf_Xword);
3256   virtual ~Output_section();
3257
3258   // Add a new input section SHNDX, named NAME, with header SHDR, from
3259   // object OBJECT.  RELOC_SHNDX is the index of a relocation section
3260   // which applies to this section, or 0 if none, or -1 if more than
3261   // one.  HAVE_SECTIONS_SCRIPT is true if we have a SECTIONS clause
3262   // in a linker script; in that case we need to keep track of input
3263   // sections associated with an output section.  Return the offset
3264   // within the output section.
3265   template<int size, bool big_endian>
3266   off_t
3267   add_input_section(Layout* layout, Sized_relobj_file<size, big_endian>* object,
3268                     unsigned int shndx, const char* name,
3269                     const elfcpp::Shdr<size, big_endian>& shdr,
3270                     unsigned int reloc_shndx, bool have_sections_script);
3271
3272   // Add generated data POSD to this output section.
3273   void
3274   add_output_section_data(Output_section_data* posd);
3275
3276   // Add a relaxed input section PORIS called NAME to this output section
3277   // with LAYOUT.
3278   void
3279   add_relaxed_input_section(Layout* layout,
3280                             Output_relaxed_input_section* poris,
3281                             const std::string& name);
3282
3283   // Return the section name.
3284   const char*
3285   name() const
3286   { return this->name_; }
3287
3288   // Return the section type.
3289   elfcpp::Elf_Word
3290   type() const
3291   { return this->type_; }
3292
3293   // Return the section flags.
3294   elfcpp::Elf_Xword
3295   flags() const
3296   { return this->flags_; }
3297
3298   typedef std::map<Section_id, unsigned int> Section_layout_order;
3299
3300   void
3301   update_section_layout(const Section_layout_order* order_map);
3302
3303   // Update the output section flags based on input section flags.
3304   void
3305   update_flags_for_input_section(elfcpp::Elf_Xword flags);
3306
3307   // Set the output section flags.
3308   void
3309   set_flags(elfcpp::Elf_Xword flags)
3310   { this->flags_ = flags; }
3311
3312   // Return the entsize field.
3313   uint64_t
3314   entsize() const
3315   { return this->entsize_; }
3316
3317   // Set the entsize field.
3318   void
3319   set_entsize(uint64_t v);
3320
3321   // Set the load address.
3322   void
3323   set_load_address(uint64_t load_address)
3324   {
3325     this->load_address_ = load_address;
3326     this->has_load_address_ = true;
3327   }
3328
3329   // Set the link field to the output section index of a section.
3330   void
3331   set_link_section(const Output_data* od)
3332   {
3333     gold_assert(this->link_ == 0
3334                 && !this->should_link_to_symtab_
3335                 && !this->should_link_to_dynsym_);
3336     this->link_section_ = od;
3337   }
3338
3339   // Set the link field to a constant.
3340   void
3341   set_link(unsigned int v)
3342   {
3343     gold_assert(this->link_section_ == NULL
3344                 && !this->should_link_to_symtab_
3345                 && !this->should_link_to_dynsym_);
3346     this->link_ = v;
3347   }
3348
3349   // Record that this section should link to the normal symbol table.
3350   void
3351   set_should_link_to_symtab()
3352   {
3353     gold_assert(this->link_section_ == NULL
3354                 && this->link_ == 0
3355                 && !this->should_link_to_dynsym_);
3356     this->should_link_to_symtab_ = true;
3357   }
3358
3359   // Record that this section should link to the dynamic symbol table.
3360   void
3361   set_should_link_to_dynsym()
3362   {
3363     gold_assert(this->link_section_ == NULL
3364                 && this->link_ == 0
3365                 && !this->should_link_to_symtab_);
3366     this->should_link_to_dynsym_ = true;
3367   }
3368
3369   // Return the info field.
3370   unsigned int
3371   info() const
3372   {
3373     gold_assert(this->info_section_ == NULL
3374                 && this->info_symndx_ == NULL);
3375     return this->info_;
3376   }
3377
3378   // Set the info field to the output section index of a section.
3379   void
3380   set_info_section(const Output_section* os)
3381   {
3382     gold_assert((this->info_section_ == NULL
3383                  || (this->info_section_ == os
3384                      && this->info_uses_section_index_))
3385                 && this->info_symndx_ == NULL
3386                 && this->info_ == 0);
3387     this->info_section_ = os;
3388     this->info_uses_section_index_= true;
3389   }
3390
3391   // Set the info field to the symbol table index of a symbol.
3392   void
3393   set_info_symndx(const Symbol* sym)
3394   {
3395     gold_assert(this->info_section_ == NULL
3396                 && (this->info_symndx_ == NULL
3397                     || this->info_symndx_ == sym)
3398                 && this->info_ == 0);
3399     this->info_symndx_ = sym;
3400   }
3401
3402   // Set the info field to the symbol table index of a section symbol.
3403   void
3404   set_info_section_symndx(const Output_section* os)
3405   {
3406     gold_assert((this->info_section_ == NULL
3407                  || (this->info_section_ == os
3408                      && !this->info_uses_section_index_))
3409                 && this->info_symndx_ == NULL
3410                 && this->info_ == 0);
3411     this->info_section_ = os;
3412     this->info_uses_section_index_ = false;
3413   }
3414
3415   // Set the info field to a constant.
3416   void
3417   set_info(unsigned int v)
3418   {
3419     gold_assert(this->info_section_ == NULL
3420                 && this->info_symndx_ == NULL
3421                 && (this->info_ == 0
3422                     || this->info_ == v));
3423     this->info_ = v;
3424   }
3425
3426   // Set the addralign field.
3427   void
3428   set_addralign(uint64_t v)
3429   { this->addralign_ = v; }
3430
3431   void
3432   checkpoint_set_addralign(uint64_t val)
3433   {
3434     if (this->checkpoint_ != NULL)
3435       this->checkpoint_->set_addralign(val);
3436   }
3437
3438   // Whether the output section index has been set.
3439   bool
3440   has_out_shndx() const
3441   { return this->out_shndx_ != -1U; }
3442
3443   // Indicate that we need a symtab index.
3444   void
3445   set_needs_symtab_index()
3446   { this->needs_symtab_index_ = true; }
3447
3448   // Return whether we need a symtab index.
3449   bool
3450   needs_symtab_index() const
3451   { return this->needs_symtab_index_; }
3452
3453   // Get the symtab index.
3454   unsigned int
3455   symtab_index() const
3456   {
3457     gold_assert(this->symtab_index_ != 0);
3458     return this->symtab_index_;
3459   }
3460
3461   // Set the symtab index.
3462   void
3463   set_symtab_index(unsigned int index)
3464   {
3465     gold_assert(index != 0);
3466     this->symtab_index_ = index;
3467   }
3468
3469   // Indicate that we need a dynsym index.
3470   void
3471   set_needs_dynsym_index()
3472   { this->needs_dynsym_index_ = true; }
3473
3474   // Return whether we need a dynsym index.
3475   bool
3476   needs_dynsym_index() const
3477   { return this->needs_dynsym_index_; }
3478
3479   // Get the dynsym index.
3480   unsigned int
3481   dynsym_index() const
3482   {
3483     gold_assert(this->dynsym_index_ != 0);
3484     return this->dynsym_index_;
3485   }
3486
3487   // Set the dynsym index.
3488   void
3489   set_dynsym_index(unsigned int index)
3490   {
3491     gold_assert(index != 0);
3492     this->dynsym_index_ = index;
3493   }
3494
3495   // Sort the attached input sections.
3496   void
3497   sort_attached_input_sections();
3498
3499   // Return whether the input sections sections attachd to this output
3500   // section may require sorting.  This is used to handle constructor
3501   // priorities compatibly with GNU ld.
3502   bool
3503   may_sort_attached_input_sections() const
3504   { return this->may_sort_attached_input_sections_; }
3505
3506   // Record that the input sections attached to this output section
3507   // may require sorting.
3508   void
3509   set_may_sort_attached_input_sections()
3510   { this->may_sort_attached_input_sections_ = true; }
3511
3512    // Returns true if input sections must be sorted according to the
3513   // order in which their name appear in the --section-ordering-file.
3514   bool
3515   input_section_order_specified()
3516   { return this->input_section_order_specified_; }
3517
3518   // Record that input sections must be sorted as some of their names
3519   // match the patterns specified through --section-ordering-file.
3520   void
3521   set_input_section_order_specified()
3522   { this->input_section_order_specified_ = true; }
3523
3524   // Return whether the input sections attached to this output section
3525   // require sorting.  This is used to handle constructor priorities
3526   // compatibly with GNU ld.
3527   bool
3528   must_sort_attached_input_sections() const
3529   { return this->must_sort_attached_input_sections_; }
3530
3531   // Record that the input sections attached to this output section
3532   // require sorting.
3533   void
3534   set_must_sort_attached_input_sections()
3535   { this->must_sort_attached_input_sections_ = true; }
3536
3537   // Get the order in which this section appears in the PT_LOAD output
3538   // segment.
3539   Output_section_order
3540   order() const
3541   { return this->order_; }
3542
3543   // Set the order for this section.
3544   void
3545   set_order(Output_section_order order)
3546   { this->order_ = order; }
3547
3548   // Return whether this section holds relro data--data which has
3549   // dynamic relocations but which may be marked read-only after the
3550   // dynamic relocations have been completed.
3551   bool
3552   is_relro() const
3553   { return this->is_relro_; }
3554
3555   // Record that this section holds relro data.
3556   void
3557   set_is_relro()
3558   { this->is_relro_ = true; }
3559
3560   // Record that this section does not hold relro data.
3561   void
3562   clear_is_relro()
3563   { this->is_relro_ = false; }
3564
3565   // True if this is a small section: a section which holds small
3566   // variables.
3567   bool
3568   is_small_section() const
3569   { return this->is_small_section_; }
3570
3571   // Record that this is a small section.
3572   void
3573   set_is_small_section()
3574   { this->is_small_section_ = true; }
3575
3576   // True if this is a large section: a section which holds large
3577   // variables.
3578   bool
3579   is_large_section() const
3580   { return this->is_large_section_; }
3581
3582   // Record that this is a large section.
3583   void
3584   set_is_large_section()
3585   { this->is_large_section_ = true; }
3586
3587   // True if this is a large data (not BSS) section.
3588   bool
3589   is_large_data_section()
3590   { return this->is_large_section_ && this->type_ != elfcpp::SHT_NOBITS; }
3591
3592   // Return whether this section should be written after all the input
3593   // sections are complete.
3594   bool
3595   after_input_sections() const
3596   { return this->after_input_sections_; }
3597
3598   // Record that this section should be written after all the input
3599   // sections are complete.
3600   void
3601   set_after_input_sections()
3602   { this->after_input_sections_ = true; }
3603
3604   // Return whether this section requires postprocessing after all
3605   // relocations have been applied.
3606   bool
3607   requires_postprocessing() const
3608   { return this->requires_postprocessing_; }
3609
3610   bool
3611   is_unique_segment() const
3612   { return this->is_unique_segment_; }
3613
3614   void
3615   set_is_unique_segment()
3616   { this->is_unique_segment_ = true; }
3617
3618   uint64_t extra_segment_flags() const
3619   { return this->extra_segment_flags_; }
3620
3621   void
3622   set_extra_segment_flags(uint64_t flags)
3623   { this->extra_segment_flags_ = flags; }
3624
3625   uint64_t segment_alignment() const
3626   { return this->segment_alignment_; }
3627
3628   void
3629   set_segment_alignment(uint64_t align)
3630   { this->segment_alignment_ = align; }
3631
3632   // If a section requires postprocessing, return the buffer to use.
3633   unsigned char*
3634   postprocessing_buffer() const
3635   {
3636     gold_assert(this->postprocessing_buffer_ != NULL);
3637     return this->postprocessing_buffer_;
3638   }
3639
3640   // If a section requires postprocessing, create the buffer to use.
3641   void
3642   create_postprocessing_buffer();
3643
3644   // If a section requires postprocessing, this is the size of the
3645   // buffer to which relocations should be applied.
3646   off_t
3647   postprocessing_buffer_size() const
3648   { return this->current_data_size_for_child(); }
3649
3650   // Modify the section name.  This is only permitted for an
3651   // unallocated section, and only before the size has been finalized.
3652   // Otherwise the name will not get into Layout::namepool_.
3653   void
3654   set_name(const char* newname)
3655   {
3656     gold_assert((this->flags_ & elfcpp::SHF_ALLOC) == 0);
3657     gold_assert(!this->is_data_size_valid());
3658     this->name_ = newname;
3659   }
3660
3661   // Return whether the offset OFFSET in the input section SHNDX in
3662   // object OBJECT is being included in the link.
3663   bool
3664   is_input_address_mapped(const Relobj* object, unsigned int shndx,
3665                           off_t offset) const;
3666
3667   // Return the offset within the output section of OFFSET relative to
3668   // the start of input section SHNDX in object OBJECT.
3669   section_offset_type
3670   output_offset(const Relobj* object, unsigned int shndx,
3671                 section_offset_type offset) const;
3672
3673   // Return the output virtual address of OFFSET relative to the start
3674   // of input section SHNDX in object OBJECT.
3675   uint64_t
3676   output_address(const Relobj* object, unsigned int shndx,
3677                  off_t offset) const;
3678
3679   // Look for the merged section for input section SHNDX in object
3680   // OBJECT.  If found, return true, and set *ADDR to the address of
3681   // the start of the merged section.  This is not necessary the
3682   // output offset corresponding to input offset 0 in the section,
3683   // since the section may be mapped arbitrarily.
3684   bool
3685   find_starting_output_address(const Relobj* object, unsigned int shndx,
3686                                uint64_t* addr) const;
3687
3688   // Record that this output section was found in the SECTIONS clause
3689   // of a linker script.
3690   void
3691   set_found_in_sections_clause()
3692   { this->found_in_sections_clause_ = true; }
3693
3694   // Return whether this output section was found in the SECTIONS
3695   // clause of a linker script.
3696   bool
3697   found_in_sections_clause() const
3698   { return this->found_in_sections_clause_; }
3699
3700   // Write the section header into *OPHDR.
3701   template<int size, bool big_endian>
3702   void
3703   write_header(const Layout*, const Stringpool*,
3704                elfcpp::Shdr_write<size, big_endian>*) const;
3705
3706   // The next few calls are for linker script support.
3707
3708   // In some cases we need to keep a list of the input sections
3709   // associated with this output section.  We only need the list if we
3710   // might have to change the offsets of the input section within the
3711   // output section after we add the input section.  The ordinary
3712   // input sections will be written out when we process the object
3713   // file, and as such we don't need to track them here.  We do need
3714   // to track Output_section_data objects here.  We store instances of
3715   // this structure in a std::vector, so it must be a POD.  There can
3716   // be many instances of this structure, so we use a union to save
3717   // some space.
3718   class Input_section
3719   {
3720    public:
3721     Input_section()
3722       : shndx_(0), p2align_(0)
3723     {
3724       this->u1_.data_size = 0;
3725       this->u2_.object = NULL;
3726     }
3727
3728     // For an ordinary input section.
3729     Input_section(Relobj* object, unsigned int shndx, off_t data_size,
3730                   uint64_t addralign)
3731       : shndx_(shndx),
3732         p2align_(ffsll(static_cast<long long>(addralign))),
3733         section_order_index_(0)
3734     {
3735       gold_assert(shndx != OUTPUT_SECTION_CODE
3736                   && shndx != MERGE_DATA_SECTION_CODE
3737                   && shndx != MERGE_STRING_SECTION_CODE
3738                   && shndx != RELAXED_INPUT_SECTION_CODE);
3739       this->u1_.data_size = data_size;
3740       this->u2_.object = object;
3741     }
3742
3743     // For a non-merge output section.
3744     Input_section(Output_section_data* posd)
3745       : shndx_(OUTPUT_SECTION_CODE), p2align_(0),
3746         section_order_index_(0)
3747     {
3748       this->u1_.data_size = 0;
3749       this->u2_.posd = posd;
3750     }
3751
3752     // For a merge section.
3753     Input_section(Output_section_data* posd, bool is_string, uint64_t entsize)
3754       : shndx_(is_string
3755                ? MERGE_STRING_SECTION_CODE
3756                : MERGE_DATA_SECTION_CODE),
3757         p2align_(0),
3758         section_order_index_(0)
3759     {
3760       this->u1_.entsize = entsize;
3761       this->u2_.posd = posd;
3762     }
3763
3764     // For a relaxed input section.
3765     Input_section(Output_relaxed_input_section* psection)
3766       : shndx_(RELAXED_INPUT_SECTION_CODE), p2align_(0),
3767         section_order_index_(0)
3768     {
3769       this->u1_.data_size = 0;
3770       this->u2_.poris = psection;
3771     }
3772
3773     unsigned int
3774     section_order_index() const
3775     {
3776       return this->section_order_index_;
3777     }
3778
3779     void
3780     set_section_order_index(unsigned int number)
3781     {
3782       this->section_order_index_ = number;
3783     }
3784
3785     // The required alignment.
3786     uint64_t
3787     addralign() const
3788     {
3789       if (this->p2align_ != 0)
3790         return static_cast<uint64_t>(1) << (this->p2align_ - 1);
3791       else if (!this->is_input_section())
3792         return this->u2_.posd->addralign();
3793       else
3794         return 0;
3795     }
3796
3797     // Set the required alignment, which must be either 0 or a power of 2.
3798     // For input sections that are sub-classes of Output_section_data, a
3799     // alignment of zero means asking the underlying object for alignment.
3800     void
3801     set_addralign(uint64_t addralign)
3802     {
3803       if (addralign == 0)
3804         this->p2align_ = 0;
3805       else
3806         {
3807           gold_assert((addralign & (addralign - 1)) == 0);
3808           this->p2align_ = ffsll(static_cast<long long>(addralign));
3809         }
3810     }
3811
3812     // Return the current required size, without finalization.
3813     off_t
3814     current_data_size() const;
3815
3816     // Return the required size.
3817     off_t
3818     data_size() const;
3819
3820     // Whether this is an input section.
3821     bool
3822     is_input_section() const
3823     {
3824       return (this->shndx_ != OUTPUT_SECTION_CODE
3825               && this->shndx_ != MERGE_DATA_SECTION_CODE
3826               && this->shndx_ != MERGE_STRING_SECTION_CODE
3827               && this->shndx_ != RELAXED_INPUT_SECTION_CODE);
3828     }
3829
3830     // Return whether this is a merge section which matches the
3831     // parameters.
3832     bool
3833     is_merge_section(bool is_string, uint64_t entsize,
3834                      uint64_t addralign) const
3835     {
3836       return (this->shndx_ == (is_string
3837                                ? MERGE_STRING_SECTION_CODE
3838                                : MERGE_DATA_SECTION_CODE)
3839               && this->u1_.entsize == entsize
3840               && this->addralign() == addralign);
3841     }
3842
3843     // Return whether this is a merge section for some input section.
3844     bool
3845     is_merge_section() const
3846     {
3847       return (this->shndx_ == MERGE_DATA_SECTION_CODE
3848               || this->shndx_ == MERGE_STRING_SECTION_CODE);
3849     }
3850
3851     // Return whether this is a relaxed input section.
3852     bool
3853     is_relaxed_input_section() const
3854     { return this->shndx_ == RELAXED_INPUT_SECTION_CODE; }
3855
3856     // Return whether this is a generic Output_section_data.
3857     bool
3858     is_output_section_data() const
3859     {
3860       return this->shndx_ == OUTPUT_SECTION_CODE;
3861     }
3862
3863     // Return the object for an input section.
3864     Relobj*
3865     relobj() const;
3866
3867     // Return the input section index for an input section.
3868     unsigned int
3869     shndx() const;
3870
3871     // For non-input-sections, return the associated Output_section_data
3872     // object.
3873     Output_section_data*
3874     output_section_data() const
3875     {
3876       gold_assert(!this->is_input_section());
3877       return this->u2_.posd;
3878     }
3879
3880     // For a merge section, return the Output_merge_base pointer.
3881     Output_merge_base*
3882     output_merge_base() const
3883     {
3884       gold_assert(this->is_merge_section());
3885       return this->u2_.pomb;
3886     }
3887
3888     // Return the Output_relaxed_input_section object.
3889     Output_relaxed_input_section*
3890     relaxed_input_section() const
3891     {
3892       gold_assert(this->is_relaxed_input_section());
3893       return this->u2_.poris;
3894     }
3895
3896     // Set the output section.
3897     void
3898     set_output_section(Output_section* os)
3899     {
3900       gold_assert(!this->is_input_section());
3901       Output_section_data* posd =
3902         this->is_relaxed_input_section() ? this->u2_.poris : this->u2_.posd;
3903       posd->set_output_section(os);
3904     }
3905
3906     // Set the address and file offset.  This is called during
3907     // Layout::finalize.  SECTION_FILE_OFFSET is the file offset of
3908     // the enclosing section.
3909     void
3910     set_address_and_file_offset(uint64_t address, off_t file_offset,
3911                                 off_t section_file_offset);
3912
3913     // Reset the address and file offset.
3914     void
3915     reset_address_and_file_offset();
3916
3917     // Finalize the data size.
3918     void
3919     finalize_data_size();
3920
3921     // Add an input section, for SHF_MERGE sections.
3922     bool
3923     add_input_section(Relobj* object, unsigned int shndx)
3924     {
3925       gold_assert(this->shndx_ == MERGE_DATA_SECTION_CODE
3926                   || this->shndx_ == MERGE_STRING_SECTION_CODE);
3927       return this->u2_.posd->add_input_section(object, shndx);
3928     }
3929
3930     // Given an input OBJECT, an input section index SHNDX within that
3931     // object, and an OFFSET relative to the start of that input
3932     // section, return whether or not the output offset is known.  If
3933     // this function returns true, it sets *POUTPUT to the offset in
3934     // the output section, relative to the start of the input section
3935     // in the output section.  *POUTPUT may be different from OFFSET
3936     // for a merged section.
3937     bool
3938     output_offset(const Relobj* object, unsigned int shndx,
3939                   section_offset_type offset,
3940                   section_offset_type* poutput) const;
3941
3942     // Write out the data.  This does nothing for an input section.
3943     void
3944     write(Output_file*);
3945
3946     // Write the data to a buffer.  This does nothing for an input
3947     // section.
3948     void
3949     write_to_buffer(unsigned char*);
3950
3951     // Print to a map file.
3952     void
3953     print_to_mapfile(Mapfile*) const;
3954
3955     // Print statistics about merge sections to stderr.
3956     void
3957     print_merge_stats(const char* section_name)
3958     {
3959       if (this->shndx_ == MERGE_DATA_SECTION_CODE
3960           || this->shndx_ == MERGE_STRING_SECTION_CODE)
3961         this->u2_.posd->print_merge_stats(section_name);
3962     }
3963
3964    private:
3965     // Code values which appear in shndx_.  If the value is not one of
3966     // these codes, it is the input section index in the object file.
3967     enum
3968     {
3969       // An Output_section_data.
3970       OUTPUT_SECTION_CODE = -1U,
3971       // An Output_section_data for an SHF_MERGE section with
3972       // SHF_STRINGS not set.
3973       MERGE_DATA_SECTION_CODE = -2U,
3974       // An Output_section_data for an SHF_MERGE section with
3975       // SHF_STRINGS set.
3976       MERGE_STRING_SECTION_CODE = -3U,
3977       // An Output_section_data for a relaxed input section.
3978       RELAXED_INPUT_SECTION_CODE = -4U
3979     };
3980
3981     // For an ordinary input section, this is the section index in the
3982     // input file.  For an Output_section_data, this is
3983     // OUTPUT_SECTION_CODE or MERGE_DATA_SECTION_CODE or
3984     // MERGE_STRING_SECTION_CODE.
3985     unsigned int shndx_;
3986     // The required alignment, stored as a power of 2.
3987     unsigned int p2align_;
3988     union
3989     {
3990       // For an ordinary input section, the section size.
3991       off_t data_size;
3992       // For OUTPUT_SECTION_CODE or RELAXED_INPUT_SECTION_CODE, this is not
3993       // used.  For MERGE_DATA_SECTION_CODE or MERGE_STRING_SECTION_CODE, the
3994       // entity size.
3995       uint64_t entsize;
3996     } u1_;
3997     union
3998     {
3999       // For an ordinary input section, the object which holds the
4000       // input section.
4001       Relobj* object;
4002       // For OUTPUT_SECTION_CODE or MERGE_DATA_SECTION_CODE or
4003       // MERGE_STRING_SECTION_CODE, the data.
4004       Output_section_data* posd;
4005       Output_merge_base* pomb;
4006       // For RELAXED_INPUT_SECTION_CODE, the data.
4007       Output_relaxed_input_section* poris;
4008     } u2_;
4009     // The line number of the pattern it matches in the --section-ordering-file
4010     // file.  It is 0 if does not match any pattern.
4011     unsigned int section_order_index_;
4012   };
4013
4014   // Store the list of input sections for this Output_section into the
4015   // list passed in.  This removes the input sections, leaving only
4016   // any Output_section_data elements.  This returns the size of those
4017   // Output_section_data elements.  ADDRESS is the address of this
4018   // output section.  FILL is the fill value to use, in case there are
4019   // any spaces between the remaining Output_section_data elements.
4020   uint64_t
4021   get_input_sections(uint64_t address, const std::string& fill,
4022                      std::list<Input_section>*);
4023
4024   // Add a script input section.  A script input section can either be
4025   // a plain input section or a sub-class of Output_section_data.
4026   void
4027   add_script_input_section(const Input_section& input_section);
4028
4029   // Set the current size of the output section.
4030   void
4031   set_current_data_size(off_t size)
4032   { this->set_current_data_size_for_child(size); }
4033
4034   // End of linker script support.
4035
4036   // Save states before doing section layout.
4037   // This is used for relaxation.
4038   void
4039   save_states();
4040
4041   // Restore states prior to section layout.
4042   void
4043   restore_states();
4044
4045   // Discard states.
4046   void
4047   discard_states();
4048
4049   // Convert existing input sections to relaxed input sections.
4050   void
4051   convert_input_sections_to_relaxed_sections(
4052       const std::vector<Output_relaxed_input_section*>& sections);
4053
4054   // Find a relaxed input section to an input section in OBJECT
4055   // with index SHNDX.  Return NULL if none is found.
4056   const Output_relaxed_input_section*
4057   find_relaxed_input_section(const Relobj* object, unsigned int shndx) const;
4058
4059   // Whether section offsets need adjustment due to relaxation.
4060   bool
4061   section_offsets_need_adjustment() const
4062   { return this->section_offsets_need_adjustment_; }
4063
4064   // Set section_offsets_need_adjustment to be true.
4065   void
4066   set_section_offsets_need_adjustment()
4067   { this->section_offsets_need_adjustment_ = true; }
4068
4069   // Set section_offsets_need_adjustment to be false.
4070   void
4071   clear_section_offsets_need_adjustment()
4072   { this->section_offsets_need_adjustment_ = false; }
4073
4074   // Adjust section offsets of input sections in this.  This is
4075   // requires if relaxation caused some input sections to change sizes.
4076   void
4077   adjust_section_offsets();
4078
4079   // Whether this is a NOLOAD section.
4080   bool
4081   is_noload() const
4082   { return this->is_noload_; }
4083
4084   // Set NOLOAD flag.
4085   void
4086   set_is_noload()
4087   { this->is_noload_ = true; }
4088
4089   // Print merge statistics to stderr.
4090   void
4091   print_merge_stats();
4092
4093   // Set a fixed layout for the section.  Used for incremental update links.
4094   void
4095   set_fixed_layout(uint64_t sh_addr, off_t sh_offset, off_t sh_size,
4096                    uint64_t sh_addralign);
4097
4098   // Return TRUE if the section has a fixed layout.
4099   bool
4100   has_fixed_layout() const
4101   { return this->has_fixed_layout_; }
4102
4103   // Set flag to allow patch space for this section.  Used for full
4104   // incremental links.
4105   void
4106   set_is_patch_space_allowed()
4107   { this->is_patch_space_allowed_ = true; }
4108
4109   // Set a fill method to use for free space left in the output section
4110   // during incremental links.
4111   void
4112   set_free_space_fill(Output_fill* free_space_fill)
4113   {
4114     this->free_space_fill_ = free_space_fill;
4115     this->free_list_.set_min_hole_size(free_space_fill->minimum_hole_size());
4116   }
4117
4118   // Reserve space within the fixed layout for the section.  Used for
4119   // incremental update links.
4120   void
4121   reserve(uint64_t sh_offset, uint64_t sh_size);
4122
4123   // Allocate space from the free list for the section.  Used for
4124   // incremental update links.
4125   off_t
4126   allocate(off_t len, uint64_t addralign);
4127
4128   typedef std::vector<Input_section> Input_section_list;
4129
4130   // Allow access to the input sections.
4131   const Input_section_list&
4132   input_sections() const
4133   { return this->input_sections_; }
4134
4135   Input_section_list&
4136   input_sections()
4137   { return this->input_sections_; }
4138
4139   // For -r and --emit-relocs, we need to keep track of the associated
4140   // relocation section.
4141   Output_section*
4142   reloc_section() const
4143   { return this->reloc_section_; }
4144
4145   void
4146   set_reloc_section(Output_section* os)
4147   { this->reloc_section_ = os; }
4148
4149  protected:
4150   // Return the output section--i.e., the object itself.
4151   Output_section*
4152   do_output_section()
4153   { return this; }
4154
4155   const Output_section*
4156   do_output_section() const
4157   { return this; }
4158
4159   // Return the section index in the output file.
4160   unsigned int
4161   do_out_shndx() const
4162   {
4163     gold_assert(this->out_shndx_ != -1U);
4164     return this->out_shndx_;
4165   }
4166
4167   // Set the output section index.
4168   void
4169   do_set_out_shndx(unsigned int shndx)
4170   {
4171     gold_assert(this->out_shndx_ == -1U || this->out_shndx_ == shndx);
4172     this->out_shndx_ = shndx;
4173   }
4174
4175   // Update the data size of the Output_section.  For a typical
4176   // Output_section, there is nothing to do, but if there are any
4177   // Output_section_data objects we need to do a trial layout
4178   // here.
4179   virtual void
4180   update_data_size();
4181
4182   // Set the final data size of the Output_section.  For a typical
4183   // Output_section, there is nothing to do, but if there are any
4184   // Output_section_data objects we need to set their final addresses
4185   // here.
4186   virtual void
4187   set_final_data_size();
4188
4189   // Reset the address and file offset.
4190   void
4191   do_reset_address_and_file_offset();
4192
4193   // Return true if address and file offset already have reset values. In
4194   // other words, calling reset_address_and_file_offset will not change them.
4195   bool
4196   do_address_and_file_offset_have_reset_values() const;
4197
4198   // Write the data to the file.  For a typical Output_section, this
4199   // does nothing: the data is written out by calling Object::Relocate
4200   // on each input object.  But if there are any Output_section_data
4201   // objects we do need to write them out here.
4202   virtual void
4203   do_write(Output_file*);
4204
4205   // Return the address alignment--function required by parent class.
4206   uint64_t
4207   do_addralign() const
4208   { return this->addralign_; }
4209
4210   // Return whether there is a load address.
4211   bool
4212   do_has_load_address() const
4213   { return this->has_load_address_; }
4214
4215   // Return the load address.
4216   uint64_t
4217   do_load_address() const
4218   {
4219     gold_assert(this->has_load_address_);
4220     return this->load_address_;
4221   }
4222
4223   // Return whether this is an Output_section.
4224   bool
4225   do_is_section() const
4226   { return true; }
4227
4228   // Return whether this is a section of the specified type.
4229   bool
4230   do_is_section_type(elfcpp::Elf_Word type) const
4231   { return this->type_ == type; }
4232
4233   // Return whether the specified section flag is set.
4234   bool
4235   do_is_section_flag_set(elfcpp::Elf_Xword flag) const
4236   { return (this->flags_ & flag) != 0; }
4237
4238   // Set the TLS offset.  Called only for SHT_TLS sections.
4239   void
4240   do_set_tls_offset(uint64_t tls_base);
4241
4242   // Return the TLS offset, relative to the base of the TLS segment.
4243   // Valid only for SHT_TLS sections.
4244   uint64_t
4245   do_tls_offset() const
4246   { return this->tls_offset_; }
4247
4248   // This may be implemented by a child class.
4249   virtual void
4250   do_finalize_name(Layout*)
4251   { }
4252
4253   // Print to the map file.
4254   virtual void
4255   do_print_to_mapfile(Mapfile*) const;
4256
4257   // Record that this section requires postprocessing after all
4258   // relocations have been applied.  This is called by a child class.
4259   void
4260   set_requires_postprocessing()
4261   {
4262     this->requires_postprocessing_ = true;
4263     this->after_input_sections_ = true;
4264   }
4265
4266   // Write all the data of an Output_section into the postprocessing
4267   // buffer.
4268   void
4269   write_to_postprocessing_buffer();
4270
4271   // Whether this always keeps an input section list
4272   bool
4273   always_keeps_input_sections() const
4274   { return this->always_keeps_input_sections_; }
4275
4276   // Always keep an input section list.
4277   void
4278   set_always_keeps_input_sections()
4279   {
4280     gold_assert(this->current_data_size_for_child() == 0);
4281     this->always_keeps_input_sections_ = true;
4282   }
4283
4284  private:
4285   // We only save enough information to undo the effects of section layout.
4286   class Checkpoint_output_section
4287   {
4288    public:
4289     Checkpoint_output_section(uint64_t addralign, elfcpp::Elf_Xword flags,
4290                               const Input_section_list& input_sections,
4291                               off_t first_input_offset,
4292                               bool attached_input_sections_are_sorted)
4293       : addralign_(addralign), flags_(flags),
4294         input_sections_(input_sections),
4295         input_sections_size_(input_sections_.size()),
4296         input_sections_copy_(), first_input_offset_(first_input_offset),
4297         attached_input_sections_are_sorted_(attached_input_sections_are_sorted)
4298     { }
4299
4300     virtual
4301     ~Checkpoint_output_section()
4302     { }
4303
4304     // Return the address alignment.
4305     uint64_t
4306     addralign() const
4307     { return this->addralign_; }
4308
4309     void
4310     set_addralign(uint64_t val)
4311     { this->addralign_ = val; }
4312
4313     // Return the section flags.
4314     elfcpp::Elf_Xword
4315     flags() const
4316     { return this->flags_; }
4317
4318     // Return a reference to the input section list copy.
4319     Input_section_list*
4320     input_sections()
4321     { return &this->input_sections_copy_; }
4322
4323     // Return the size of input_sections at the time when checkpoint is
4324     // taken.
4325     size_t
4326     input_sections_size() const
4327     { return this->input_sections_size_; }
4328
4329     // Whether input sections are copied.
4330     bool
4331     input_sections_saved() const
4332     { return this->input_sections_copy_.size() == this->input_sections_size_; }
4333
4334     off_t
4335     first_input_offset() const
4336     { return this->first_input_offset_; }
4337
4338     bool
4339     attached_input_sections_are_sorted() const
4340     { return this->attached_input_sections_are_sorted_; }
4341
4342     // Save input sections.
4343     void
4344     save_input_sections()
4345     {
4346       this->input_sections_copy_.reserve(this->input_sections_size_);
4347       this->input_sections_copy_.clear();
4348       Input_section_list::const_iterator p = this->input_sections_.begin();
4349       gold_assert(this->input_sections_size_ >= this->input_sections_.size());
4350       for(size_t i = 0; i < this->input_sections_size_ ; i++, ++p)
4351         this->input_sections_copy_.push_back(*p);
4352     }
4353
4354    private:
4355     // The section alignment.
4356     uint64_t addralign_;
4357     // The section flags.
4358     elfcpp::Elf_Xword flags_;
4359     // Reference to the input sections to be checkpointed.
4360     const Input_section_list& input_sections_;
4361     // Size of the checkpointed portion of input_sections_;
4362     size_t input_sections_size_;
4363     // Copy of input sections.
4364     Input_section_list input_sections_copy_;
4365     // The offset of the first entry in input_sections_.
4366     off_t first_input_offset_;
4367     // True if the input sections attached to this output section have
4368     // already been sorted.
4369     bool attached_input_sections_are_sorted_;
4370   };
4371
4372   // This class is used to sort the input sections.
4373   class Input_section_sort_entry;
4374
4375   // This is the sort comparison function for ctors and dtors.
4376   struct Input_section_sort_compare
4377   {
4378     bool
4379     operator()(const Input_section_sort_entry&,
4380                const Input_section_sort_entry&) const;
4381   };
4382
4383   // This is the sort comparison function for .init_array and .fini_array.
4384   struct Input_section_sort_init_fini_compare
4385   {
4386     bool
4387     operator()(const Input_section_sort_entry&,
4388                const Input_section_sort_entry&) const;
4389   };
4390
4391   // This is the sort comparison function when a section order is specified
4392   // from an input file.
4393   struct Input_section_sort_section_order_index_compare
4394   {
4395     bool
4396     operator()(const Input_section_sort_entry&,
4397                const Input_section_sort_entry&) const;
4398   };
4399
4400   // This is the sort comparison function for .text to sort sections with
4401   // prefixes .text.{unlikely,exit,startup,hot} before other sections.
4402   struct Input_section_sort_section_prefix_special_ordering_compare
4403   {
4404     bool
4405     operator()(const Input_section_sort_entry&,
4406                const Input_section_sort_entry&) const;
4407   };
4408
4409   // This is the sort comparison function for sorting sections by name.
4410   struct Input_section_sort_section_name_compare
4411   {
4412     bool
4413     operator()(const Input_section_sort_entry&,
4414                const Input_section_sort_entry&) const;
4415   };
4416
4417   // Fill data.  This is used to fill in data between input sections.
4418   // It is also used for data statements (BYTE, WORD, etc.) in linker
4419   // scripts.  When we have to keep track of the input sections, we
4420   // can use an Output_data_const, but we don't want to have to keep
4421   // track of input sections just to implement fills.
4422   class Fill
4423   {
4424    public:
4425     Fill(off_t section_offset, off_t length)
4426       : section_offset_(section_offset),
4427         length_(convert_to_section_size_type(length))
4428     { }
4429
4430     // Return section offset.
4431     off_t
4432     section_offset() const
4433     { return this->section_offset_; }
4434
4435     // Return fill length.
4436     section_size_type
4437     length() const
4438     { return this->length_; }
4439
4440    private:
4441     // The offset within the output section.
4442     off_t section_offset_;
4443     // The length of the space to fill.
4444     section_size_type length_;
4445   };
4446
4447   typedef std::vector<Fill> Fill_list;
4448
4449   // Map used during relaxation of existing sections.  This map
4450   // a section id an input section list index.  We assume that
4451   // Input_section_list is a vector.
4452   typedef Unordered_map<Section_id, size_t, Section_id_hash> Relaxation_map;
4453
4454   // Add a new output section by Input_section.
4455   void
4456   add_output_section_data(Input_section*);
4457
4458   // Add an SHF_MERGE input section.  Returns true if the section was
4459   // handled.  If KEEPS_INPUT_SECTIONS is true, the output merge section
4460   // stores information about the merged input sections.
4461   bool
4462   add_merge_input_section(Relobj* object, unsigned int shndx, uint64_t flags,
4463                           uint64_t entsize, uint64_t addralign,
4464                           bool keeps_input_sections);
4465
4466   // Add an output SHF_MERGE section POSD to this output section.
4467   // IS_STRING indicates whether it is a SHF_STRINGS section, and
4468   // ENTSIZE is the entity size.  This returns the entry added to
4469   // input_sections_.
4470   void
4471   add_output_merge_section(Output_section_data* posd, bool is_string,
4472                            uint64_t entsize);
4473
4474   // Find the merge section into which an input section with index SHNDX in
4475   // OBJECT has been added.  Return NULL if none found.
4476   const Output_section_data*
4477   find_merge_section(const Relobj* object, unsigned int shndx) const;
4478
4479   // Build a relaxation map.
4480   void
4481   build_relaxation_map(
4482       const Input_section_list& input_sections,
4483       size_t limit,
4484       Relaxation_map* map) const;
4485
4486   // Convert input sections in an input section list into relaxed sections.
4487   void
4488   convert_input_sections_in_list_to_relaxed_sections(
4489       const std::vector<Output_relaxed_input_section*>& relaxed_sections,
4490       const Relaxation_map& map,
4491       Input_section_list* input_sections);
4492
4493   // Build the lookup maps for merge and relaxed input sections.
4494   void
4495   build_lookup_maps() const;
4496
4497   // Most of these fields are only valid after layout.
4498
4499   // The name of the section.  This will point into a Stringpool.
4500   const char* name_;
4501   // The section address is in the parent class.
4502   // The section alignment.
4503   uint64_t addralign_;
4504   // The section entry size.
4505   uint64_t entsize_;
4506   // The load address.  This is only used when using a linker script
4507   // with a SECTIONS clause.  The has_load_address_ field indicates
4508   // whether this field is valid.
4509   uint64_t load_address_;
4510   // The file offset is in the parent class.
4511   // Set the section link field to the index of this section.
4512   const Output_data* link_section_;
4513   // If link_section_ is NULL, this is the link field.
4514   unsigned int link_;
4515   // Set the section info field to the index of this section.
4516   const Output_section* info_section_;
4517   // If info_section_ is NULL, set the info field to the symbol table
4518   // index of this symbol.
4519   const Symbol* info_symndx_;
4520   // If info_section_ and info_symndx_ are NULL, this is the section
4521   // info field.
4522   unsigned int info_;
4523   // The section type.
4524   const elfcpp::Elf_Word type_;
4525   // The section flags.
4526   elfcpp::Elf_Xword flags_;
4527   // The order of this section in the output segment.
4528   Output_section_order order_;
4529   // The section index.
4530   unsigned int out_shndx_;
4531   // If there is a STT_SECTION for this output section in the normal
4532   // symbol table, this is the symbol index.  This starts out as zero.
4533   // It is initialized in Layout::finalize() to be the index, or -1U
4534   // if there isn't one.
4535   unsigned int symtab_index_;
4536   // If there is a STT_SECTION for this output section in the dynamic
4537   // symbol table, this is the symbol index.  This starts out as zero.
4538   // It is initialized in Layout::finalize() to be the index, or -1U
4539   // if there isn't one.
4540   unsigned int dynsym_index_;
4541   // The input sections.  This will be empty in cases where we don't
4542   // need to keep track of them.
4543   Input_section_list input_sections_;
4544   // The offset of the first entry in input_sections_.
4545   off_t first_input_offset_;
4546   // The fill data.  This is separate from input_sections_ because we
4547   // often will need fill sections without needing to keep track of
4548   // input sections.
4549   Fill_list fills_;
4550   // If the section requires postprocessing, this buffer holds the
4551   // section contents during relocation.
4552   unsigned char* postprocessing_buffer_;
4553   // Whether this output section needs a STT_SECTION symbol in the
4554   // normal symbol table.  This will be true if there is a relocation
4555   // which needs it.
4556   bool needs_symtab_index_ : 1;
4557   // Whether this output section needs a STT_SECTION symbol in the
4558   // dynamic symbol table.  This will be true if there is a dynamic
4559   // relocation which needs it.
4560   bool needs_dynsym_index_ : 1;
4561   // Whether the link field of this output section should point to the
4562   // normal symbol table.
4563   bool should_link_to_symtab_ : 1;
4564   // Whether the link field of this output section should point to the
4565   // dynamic symbol table.
4566   bool should_link_to_dynsym_ : 1;
4567   // Whether this section should be written after all the input
4568   // sections are complete.
4569   bool after_input_sections_ : 1;
4570   // Whether this section requires post processing after all
4571   // relocations have been applied.
4572   bool requires_postprocessing_ : 1;
4573   // Whether an input section was mapped to this output section
4574   // because of a SECTIONS clause in a linker script.
4575   bool found_in_sections_clause_ : 1;
4576   // Whether this section has an explicitly specified load address.
4577   bool has_load_address_ : 1;
4578   // True if the info_section_ field means the section index of the
4579   // section, false if it means the symbol index of the corresponding
4580   // section symbol.
4581   bool info_uses_section_index_ : 1;
4582   // True if input sections attached to this output section have to be
4583   // sorted according to a specified order.
4584   bool input_section_order_specified_ : 1;
4585   // True if the input sections attached to this output section may
4586   // need sorting.
4587   bool may_sort_attached_input_sections_ : 1;
4588   // True if the input sections attached to this output section must
4589   // be sorted.
4590   bool must_sort_attached_input_sections_ : 1;
4591   // True if the input sections attached to this output section have
4592   // already been sorted.
4593   bool attached_input_sections_are_sorted_ : 1;
4594   // True if this section holds relro data.
4595   bool is_relro_ : 1;
4596   // True if this is a small section.
4597   bool is_small_section_ : 1;
4598   // True if this is a large section.
4599   bool is_large_section_ : 1;
4600   // Whether code-fills are generated at write.
4601   bool generate_code_fills_at_write_ : 1;
4602   // Whether the entry size field should be zero.
4603   bool is_entsize_zero_ : 1;
4604   // Whether section offsets need adjustment due to relaxation.
4605   bool section_offsets_need_adjustment_ : 1;
4606   // Whether this is a NOLOAD section.
4607   bool is_noload_ : 1;
4608   // Whether this always keeps input section.
4609   bool always_keeps_input_sections_ : 1;
4610   // Whether this section has a fixed layout, for incremental update links.
4611   bool has_fixed_layout_ : 1;
4612   // True if we can add patch space to this section.
4613   bool is_patch_space_allowed_ : 1;
4614   // True if this output section goes into a unique segment.
4615   bool is_unique_segment_ : 1;
4616   // For SHT_TLS sections, the offset of this section relative to the base
4617   // of the TLS segment.
4618   uint64_t tls_offset_;
4619   // Additional segment flags, specified via linker plugin, when mapping some
4620   // input sections to unique segments.
4621   uint64_t extra_segment_flags_;
4622   // Segment alignment specified via linker plugin, when mapping some
4623   // input sections to unique segments.
4624   uint64_t segment_alignment_;
4625   // Saved checkpoint.
4626   Checkpoint_output_section* checkpoint_;
4627   // Fast lookup maps for merged and relaxed input sections.
4628   Output_section_lookup_maps* lookup_maps_;
4629   // List of available regions within the section, for incremental
4630   // update links.
4631   Free_list free_list_;
4632   // Method for filling chunks of free space.
4633   Output_fill* free_space_fill_;
4634   // Amount added as patch space for incremental linking.
4635   off_t patch_space_;
4636   // Associated relocation section, when emitting relocations.
4637   Output_section* reloc_section_;
4638 };
4639
4640 // An output segment.  PT_LOAD segments are built from collections of
4641 // output sections.  Other segments typically point within PT_LOAD
4642 // segments, and are built directly as needed.
4643 //
4644 // NOTE: We want to use the copy constructor for this class.  During
4645 // relaxation, we may try built the segments multiple times.  We do
4646 // that by copying the original segment list before lay-out, doing
4647 // a trial lay-out and roll-back to the saved copied if we need to
4648 // to the lay-out again.
4649
4650 class Output_segment
4651 {
4652  public:
4653   // Create an output segment, specifying the type and flags.
4654   Output_segment(elfcpp::Elf_Word, elfcpp::Elf_Word);
4655
4656   // Return the virtual address.
4657   uint64_t
4658   vaddr() const
4659   { return this->vaddr_; }
4660
4661   // Return the physical address.
4662   uint64_t
4663   paddr() const
4664   { return this->paddr_; }
4665
4666   // Return the segment type.
4667   elfcpp::Elf_Word
4668   type() const
4669   { return this->type_; }
4670
4671   // Return the segment flags.
4672   elfcpp::Elf_Word
4673   flags() const
4674   { return this->flags_; }
4675
4676   // Return the memory size.
4677   uint64_t
4678   memsz() const
4679   { return this->memsz_; }
4680
4681   // Return the file size.
4682   off_t
4683   filesz() const
4684   { return this->filesz_; }
4685
4686   // Return the file offset.
4687   off_t
4688   offset() const
4689   { return this->offset_; }
4690
4691   // Whether this is a segment created to hold large data sections.
4692   bool
4693   is_large_data_segment() const
4694   { return this->is_large_data_segment_; }
4695
4696   // Record that this is a segment created to hold large data
4697   // sections.
4698   void
4699   set_is_large_data_segment()
4700   { this->is_large_data_segment_ = true; }
4701
4702   bool
4703   is_unique_segment() const
4704   { return this->is_unique_segment_; }
4705
4706   // Mark segment as unique, happens when linker plugins request that
4707   // certain input sections be mapped to unique segments.
4708   void
4709   set_is_unique_segment()
4710   { this->is_unique_segment_ = true; }
4711
4712   // Return the maximum alignment of the Output_data.
4713   uint64_t
4714   maximum_alignment();
4715
4716   // Add the Output_section OS to this PT_LOAD segment.  SEG_FLAGS is
4717   // the segment flags to use.
4718   void
4719   add_output_section_to_load(Layout* layout, Output_section* os,
4720                              elfcpp::Elf_Word seg_flags);
4721
4722   // Add the Output_section OS to this non-PT_LOAD segment.  SEG_FLAGS
4723   // is the segment flags to use.
4724   void
4725   add_output_section_to_nonload(Output_section* os,
4726                                 elfcpp::Elf_Word seg_flags);
4727
4728   // Remove an Output_section from this segment.  It is an error if it
4729   // is not present.
4730   void
4731   remove_output_section(Output_section* os);
4732
4733   // Add an Output_data (which need not be an Output_section) to the
4734   // start of this segment.
4735   void
4736   add_initial_output_data(Output_data*);
4737
4738   // Return true if this segment has any sections which hold actual
4739   // data, rather than being a BSS section.
4740   bool
4741   has_any_data_sections() const;
4742
4743   // Whether this segment has a dynamic relocs.
4744   bool
4745   has_dynamic_reloc() const;
4746
4747   // Return the first section.
4748   Output_section*
4749   first_section() const;
4750
4751   // Return the address of the first section.
4752   uint64_t
4753   first_section_load_address() const
4754   {
4755     const Output_section* os = this->first_section();
4756     gold_assert(os != NULL);
4757     return os->has_load_address() ? os->load_address() : os->address();
4758   }
4759
4760   // Return whether the addresses have been set already.
4761   bool
4762   are_addresses_set() const
4763   { return this->are_addresses_set_; }
4764
4765   // Set the addresses.
4766   void
4767   set_addresses(uint64_t vaddr, uint64_t paddr)
4768   {
4769     this->vaddr_ = vaddr;
4770     this->paddr_ = paddr;
4771     this->are_addresses_set_ = true;
4772   }
4773
4774   // Update the flags for the flags of an output section added to this
4775   // segment.
4776   void
4777   update_flags_for_output_section(elfcpp::Elf_Xword flags)
4778   {
4779     // The ELF ABI specifies that a PT_TLS segment should always have
4780     // PF_R as the flags.
4781     if (this->type() != elfcpp::PT_TLS)
4782       this->flags_ |= flags;
4783   }
4784
4785   // Set the segment flags.  This is only used if we have a PHDRS
4786   // clause which explicitly specifies the flags.
4787   void
4788   set_flags(elfcpp::Elf_Word flags)
4789   { this->flags_ = flags; }
4790
4791   // Set the address of the segment to ADDR and the offset to *POFF
4792   // and set the addresses and offsets of all contained output
4793   // sections accordingly.  Set the section indexes of all contained
4794   // output sections starting with *PSHNDX.  If RESET is true, first
4795   // reset the addresses of the contained sections.  Return the
4796   // address of the immediately following segment.  Update *POFF and
4797   // *PSHNDX.  This should only be called for a PT_LOAD segment.
4798   uint64_t
4799   set_section_addresses(const Target*, Layout*, bool reset, uint64_t addr,
4800                         unsigned int* increase_relro, bool* has_relro,
4801                         off_t* poff, unsigned int* pshndx);
4802
4803   // Set the minimum alignment of this segment.  This may be adjusted
4804   // upward based on the section alignments.
4805   void
4806   set_minimum_p_align(uint64_t align)
4807   {
4808     if (align > this->min_p_align_)
4809       this->min_p_align_ = align;
4810   }
4811
4812   // Set the memory size of this segment.
4813   void
4814   set_size(uint64_t size)
4815   {
4816     this->memsz_ = size;
4817   }
4818
4819   // Set the offset of this segment based on the section.  This should
4820   // only be called for a non-PT_LOAD segment.
4821   void
4822   set_offset(unsigned int increase);
4823
4824   // Set the TLS offsets of the sections contained in the PT_TLS segment.
4825   void
4826   set_tls_offsets();
4827
4828   // Return the number of output sections.
4829   unsigned int
4830   output_section_count() const;
4831
4832   // Return the section attached to the list segment with the lowest
4833   // load address.  This is used when handling a PHDRS clause in a
4834   // linker script.
4835   Output_section*
4836   section_with_lowest_load_address() const;
4837
4838   // Write the segment header into *OPHDR.
4839   template<int size, bool big_endian>
4840   void
4841   write_header(elfcpp::Phdr_write<size, big_endian>*);
4842
4843   // Write the section headers of associated sections into V.
4844   template<int size, bool big_endian>
4845   unsigned char*
4846   write_section_headers(const Layout*, const Stringpool*, unsigned char* v,
4847                         unsigned int* pshndx) const;
4848
4849   // Print the output sections in the map file.
4850   void
4851   print_sections_to_mapfile(Mapfile*) const;
4852
4853  private:
4854   typedef std::vector<Output_data*> Output_data_list;
4855
4856   // Find the maximum alignment in an Output_data_list.
4857   static uint64_t
4858   maximum_alignment_list(const Output_data_list*);
4859
4860   // Return whether the first data section is a relro section.
4861   bool
4862   is_first_section_relro() const;
4863
4864   // Set the section addresses in an Output_data_list.
4865   uint64_t
4866   set_section_list_addresses(Layout*, bool reset, Output_data_list*,
4867                              uint64_t addr, off_t* poff, off_t* fpoff,
4868                              unsigned int* pshndx, bool* in_tls);
4869
4870   // Return the number of Output_sections in an Output_data_list.
4871   unsigned int
4872   output_section_count_list(const Output_data_list*) const;
4873
4874   // Return whether an Output_data_list has a dynamic reloc.
4875   bool
4876   has_dynamic_reloc_list(const Output_data_list*) const;
4877
4878   // Find the section with the lowest load address in an
4879   // Output_data_list.
4880   void
4881   lowest_load_address_in_list(const Output_data_list* pdl,
4882                               Output_section** found,
4883                               uint64_t* found_lma) const;
4884
4885   // Find the first and last entries by address.
4886   void
4887   find_first_and_last_list(const Output_data_list* pdl,
4888                            const Output_data** pfirst,
4889                            const Output_data** plast) const;
4890
4891   // Write the section headers in the list into V.
4892   template<int size, bool big_endian>
4893   unsigned char*
4894   write_section_headers_list(const Layout*, const Stringpool*,
4895                              const Output_data_list*, unsigned char* v,
4896                              unsigned int* pshdx) const;
4897
4898   // Print a section list to the mapfile.
4899   void
4900   print_section_list_to_mapfile(Mapfile*, const Output_data_list*) const;
4901
4902   // NOTE: We want to use the copy constructor.  Currently, shallow copy
4903   // works for us so we do not need to write our own copy constructor.
4904
4905   // The list of output data attached to this segment.
4906   Output_data_list output_lists_[ORDER_MAX];
4907   // The segment virtual address.
4908   uint64_t vaddr_;
4909   // The segment physical address.
4910   uint64_t paddr_;
4911   // The size of the segment in memory.
4912   uint64_t memsz_;
4913   // The maximum section alignment.  The is_max_align_known_ field
4914   // indicates whether this has been finalized.
4915   uint64_t max_align_;
4916   // The required minimum value for the p_align field.  This is used
4917   // for PT_LOAD segments.  Note that this does not mean that
4918   // addresses should be aligned to this value; it means the p_paddr
4919   // and p_vaddr fields must be congruent modulo this value.  For
4920   // non-PT_LOAD segments, the dynamic linker works more efficiently
4921   // if the p_align field has the more conventional value, although it
4922   // can align as needed.
4923   uint64_t min_p_align_;
4924   // The offset of the segment data within the file.
4925   off_t offset_;
4926   // The size of the segment data in the file.
4927   off_t filesz_;
4928   // The segment type;
4929   elfcpp::Elf_Word type_;
4930   // The segment flags.
4931   elfcpp::Elf_Word flags_;
4932   // Whether we have finalized max_align_.
4933   bool is_max_align_known_ : 1;
4934   // Whether vaddr and paddr were set by a linker script.
4935   bool are_addresses_set_ : 1;
4936   // Whether this segment holds large data sections.
4937   bool is_large_data_segment_ : 1;
4938   // Whether this was marked as a unique segment via a linker plugin.
4939   bool is_unique_segment_ : 1;
4940 };
4941
4942 } // End namespace gold.
4943
4944 #endif // !defined(GOLD_OUTPUT_H)