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