1 // merge.h -- handle section merging for gold -*- C++ -*-
3 // Copyright (C) 2006-2015 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
30 #include "stringpool.h"
36 // For each object with merge sections, we store an Object_merge_map.
37 // This is used to map locations in input sections to a merged output
38 // section. The output section itself is not recorded here--it can be
39 // found in the output_sections_ field of the Object.
41 class Object_merge_map
45 : first_shnum_(-1U), first_map_(),
46 second_shnum_(-1U), second_map_(),
52 // Add a mapping for MERGE_MAP, for the bytes from OFFSET to OFFSET
53 // + LENGTH in the input section SHNDX to OUTPUT_OFFSET in the
54 // output section. An OUTPUT_OFFSET of -1 means that the bytes are
55 // discarded. OUTPUT_OFFSET is relative to the start of the merged
56 // data in the output section.
58 add_mapping(const Output_section_data
*, unsigned int shndx
,
59 section_offset_type offset
, section_size_type length
,
60 section_offset_type output_offset
);
62 // Get the output offset for an input address. MERGE_MAP is the map
63 // we are looking for, or NULL if we don't care. The input address
64 // is at offset OFFSET in section SHNDX. This sets *OUTPUT_OFFSET
65 // to the offset in the output section; this will be -1 if the bytes
66 // are not being copied to the output. This returns true if the
67 // mapping is known, false otherwise. *OUTPUT_OFFSET is relative to
68 // the start of the merged data in the output section.
70 get_output_offset(unsigned int shndx
,
71 section_offset_type offset
,
72 section_offset_type
* output_offset
);
74 // Return whether this is the merge map for section SHNDX.
76 is_merge_section_for(const Output_section_data
*, unsigned int shndx
);
78 // Initialize an mapping from input offsets to output addresses for
79 // section SHNDX. STARTING_ADDRESS is the output address of the
83 initialize_input_to_output_map(
85 typename
elfcpp::Elf_types
<size
>::Elf_Addr starting_address
,
86 Unordered_map
<section_offset_type
,
87 typename
elfcpp::Elf_types
<size
>::Elf_Addr
>*);
90 // Map input section offsets to a length and an output section
91 // offset. An output section offset of -1 means that this part of
92 // the input section is being discarded.
93 struct Input_merge_entry
95 // The offset in the input section.
96 section_offset_type input_offset
;
98 section_size_type length
;
99 // The offset in the output section.
100 section_offset_type output_offset
;
103 // A less-than comparison routine for Input_merge_entry.
104 struct Input_merge_compare
107 operator()(const Input_merge_entry
& i1
, const Input_merge_entry
& i2
) const
108 { return i1
.input_offset
< i2
.input_offset
; }
111 // A list of entries for a particular input section.
112 struct Input_merge_map
114 typedef std::vector
<Input_merge_entry
> Entries
;
116 // We store these with the Relobj, and we look them up by input
117 // section. It is possible to have two different merge maps
118 // associated with a single output section. For example, this
119 // happens routinely with .rodata, when merged string constants
120 // and merged fixed size constants are both put into .rodata. The
121 // output offset that we store is not the offset from the start of
122 // the output section; it is the offset from the start of the
123 // merged data in the output section. That means that the caller
124 // is going to add the offset of the merged data within the output
125 // section, which means that the caller needs to know which set of
126 // merged data it found the entry in. So it's not enough to find
127 // this data based on the input section and the output section; we
128 // also have to find it based on a set of merged data in the
129 // output section. In order to verify that we are looking at the
130 // right data, we store a pointer to the Merge_map here, and we
131 // pass in a pointer when looking at the data. If we are asked to
132 // look up information for a different Merge_map, we report that
133 // we don't have it, rather than trying a lookup and returning an
134 // answer which will receive the wrong offset.
135 const Output_section_data
* output_data
;
136 // The list of mappings.
138 // Whether the ENTRIES field is sorted by input_offset.
142 : output_data(NULL
), entries(), sorted(true)
146 // Map input section indices to merge maps.
147 typedef std::map
<unsigned int, Input_merge_map
*> Section_merge_maps
;
149 // Return a pointer to the Input_merge_map to use for the input
150 // section SHNDX, or NULL.
152 get_input_merge_map(unsigned int shndx
);
154 // Get or make the Input_merge_map to use for the section SHNDX
157 get_or_make_input_merge_map(const Output_section_data
* merge_map
,
160 // Any given object file will normally only have a couple of input
161 // sections with mergeable contents. So we keep the first two input
162 // section numbers inline, and push any further ones into a map. A
163 // value of -1U in first_shnum_ or second_shnum_ means that we don't
164 // have a corresponding entry.
165 unsigned int first_shnum_
;
166 Input_merge_map first_map_
;
167 unsigned int second_shnum_
;
168 Input_merge_map second_map_
;
169 Section_merge_maps section_merge_maps_
;
172 // A general class for SHF_MERGE data, to hold functions shared by
173 // fixed-size constant data and string data.
175 class Output_merge_base
: public Output_section_data
178 Output_merge_base(uint64_t entsize
, uint64_t addralign
)
179 : Output_section_data(addralign
), entsize_(entsize
),
180 keeps_input_sections_(false), first_relobj_(NULL
), first_shndx_(-1),
184 // Return the entry size.
187 { return this->entsize_
; }
189 // Whether this is a merge string section. This is only true of
190 // Output_merge_string.
193 { return this->do_is_string(); }
195 // Whether this keeps input sections.
197 keeps_input_sections() const
198 { return this->keeps_input_sections_
; }
200 // Set the keeps-input-sections flag. This is virtual so that sub-classes
201 // can perform additional checks.
203 set_keeps_input_sections()
204 { this->do_set_keeps_input_sections(); }
206 // Return the object of the first merged input section. This used
207 // for script processing. This is NULL if merge section is empty.
210 { return this->first_relobj_
; }
212 // Return the section index of the first merged input section. This
213 // is used for script processing. This is valid only if merge section
218 gold_assert(this->first_relobj_
!= NULL
);
219 return this->first_shndx_
;
222 // Set of merged input sections.
223 typedef Unordered_set
<Section_id
, Section_id_hash
> Input_sections
;
225 // Beginning of merged input sections.
226 Input_sections::const_iterator
227 input_sections_begin() const
229 gold_assert(this->keeps_input_sections_
);
230 return this->input_sections_
.begin();
233 // Beginning of merged input sections.
234 Input_sections::const_iterator
235 input_sections_end() const
237 gold_assert(this->keeps_input_sections_
);
238 return this->input_sections_
.end();
242 // Return the output offset for an input offset.
244 do_output_offset(const Relobj
* object
, unsigned int shndx
,
245 section_offset_type offset
,
246 section_offset_type
* poutput
) const;
248 // This may be overridden by the child class.
253 // This may be overridden by the child class.
255 do_set_keeps_input_sections()
256 { this->keeps_input_sections_
= true; }
258 // Record the merged input section for script processing.
260 record_input_section(Relobj
* relobj
, unsigned int shndx
);
263 // The entry size. For fixed-size constants, this is the size of
264 // the constants. For strings, this is the size of a character.
266 // Whether we keep input sections.
267 bool keeps_input_sections_
;
268 // Object of the first merged input section. We use this for script
270 Relobj
* first_relobj_
;
271 // Section index of the first merged input section.
272 unsigned int first_shndx_
;
273 // Input sections. We only keep them is keeps_input_sections_ is true.
274 Input_sections input_sections_
;
277 // Handle SHF_MERGE sections with fixed-size constant data.
279 class Output_merge_data
: public Output_merge_base
282 Output_merge_data(uint64_t entsize
, uint64_t addralign
)
283 : Output_merge_base(entsize
, addralign
), p_(NULL
), len_(0), alc_(0),
285 hashtable_(128, Merge_data_hash(this), Merge_data_eq(this))
289 // Add an input section.
291 do_add_input_section(Relobj
* object
, unsigned int shndx
);
293 // Set the final data size.
295 set_final_data_size();
297 // Write the data to the file.
299 do_write(Output_file
*);
301 // Write the data to a buffer.
303 do_write_to_buffer(unsigned char*);
305 // Write to a map file.
307 do_print_to_mapfile(Mapfile
* mapfile
) const
308 { mapfile
->print_output_data(this, _("** merge constants")); }
310 // Print merge stats to stderr.
312 do_print_merge_stats(const char* section_name
);
314 // Set keeps-input-sections flag.
316 do_set_keeps_input_sections()
318 gold_assert(this->input_count_
== 0);
319 Output_merge_base::do_set_keeps_input_sections();
323 // We build a hash table of the fixed-size constants. Each constant
324 // is stored as a pointer into the section data we are accumulating.
326 // A key in the hash table. This is an offset in the section
327 // contents we are building.
328 typedef section_offset_type Merge_data_key
;
330 // Compute the hash code. To do this we need a pointer back to the
331 // object holding the data.
332 class Merge_data_hash
335 Merge_data_hash(const Output_merge_data
* pomd
)
340 operator()(Merge_data_key
) const;
343 const Output_merge_data
* pomd_
;
346 friend class Merge_data_hash
;
348 // Compare two entries in the hash table for equality. To do this
349 // we need a pointer back to the object holding the data. Note that
350 // we now have a pointer to the object stored in two places in the
351 // hash table. Fixing this would require specializing the hash
352 // table, which would be hard to do portably.
356 Merge_data_eq(const Output_merge_data
* pomd
)
361 operator()(Merge_data_key k1
, Merge_data_key k2
) const;
364 const Output_merge_data
* pomd_
;
367 friend class Merge_data_eq
;
369 // The type of the hash table.
370 typedef Unordered_set
<Merge_data_key
, Merge_data_hash
, Merge_data_eq
>
371 Merge_data_hashtable
;
373 // Given a hash table key, which is just an offset into the section
374 // data, return a pointer to the corresponding constant.
376 constant(Merge_data_key k
) const
378 gold_assert(k
>= 0 && k
< static_cast<section_offset_type
>(this->len_
));
382 // Add a constant to the output.
384 add_constant(const unsigned char*);
386 // The accumulated data.
388 // The length of the accumulated data.
389 section_size_type len_
;
390 // The size of the allocated buffer.
391 section_size_type alc_
;
392 // The number of entries seen in input files.
395 Merge_data_hashtable hashtable_
;
398 // Handle SHF_MERGE sections with string data. This is a template
399 // based on the type of the characters in the string.
401 template<typename Char_type
>
402 class Output_merge_string
: public Output_merge_base
405 Output_merge_string(uint64_t addralign
)
406 : Output_merge_base(sizeof(Char_type
), addralign
), stringpool_(addralign
),
407 merged_strings_lists_(), input_count_(0), input_size_(0)
409 this->stringpool_
.set_no_zero_null();
413 // Add an input section.
415 do_add_input_section(Relobj
* object
, unsigned int shndx
);
417 // Do all the final processing after the input sections are read in.
418 // Returns the final data size.
420 finalize_merged_data();
422 // Set the final data size.
424 set_final_data_size();
426 // Write the data to the file.
428 do_write(Output_file
*);
430 // Write the data to a buffer.
432 do_write_to_buffer(unsigned char*);
434 // Write to a map file.
436 do_print_to_mapfile(Mapfile
* mapfile
) const
437 { mapfile
->print_output_data(this, _("** merge strings")); }
439 // Print merge stats to stderr.
441 do_print_merge_stats(const char* section_name
);
443 // Writes the stringpool to a buffer.
445 stringpool_to_buffer(unsigned char* buffer
, section_size_type buffer_size
)
446 { this->stringpool_
.write_to_buffer(buffer
, buffer_size
); }
448 // Clears all the data in the stringpool, to save on memory.
451 { this->stringpool_
.clear(); }
453 // Whether this is a merge string section.
458 // Set keeps-input-sections flag.
460 do_set_keeps_input_sections()
462 gold_assert(this->input_count_
== 0);
463 Output_merge_base::do_set_keeps_input_sections();
467 // The name of the string type, for stats.
471 // As we see input sections, we build a mapping from object, section
472 // index and offset to strings.
475 // The offset in the input section.
476 section_offset_type offset
;
477 // The key in the Stringpool.
478 Stringpool::Key stringpool_key
;
480 Merged_string(section_offset_type offseta
, Stringpool::Key stringpool_keya
)
481 : offset(offseta
), stringpool_key(stringpool_keya
)
485 typedef std::vector
<Merged_string
> Merged_strings
;
487 struct Merged_strings_list
489 // The input object where the strings were found.
491 // The input section in the input object.
493 // The list of merged strings.
494 Merged_strings merged_strings
;
496 Merged_strings_list(Relobj
* objecta
, unsigned int shndxa
)
497 : object(objecta
), shndx(shndxa
), merged_strings()
501 typedef std::vector
<Merged_strings_list
*> Merged_strings_lists
;
503 // As we see the strings, we add them to a Stringpool.
504 Stringpool_template
<Char_type
> stringpool_
;
505 // Map from a location in an input object to an entry in the
507 Merged_strings_lists merged_strings_lists_
;
508 // The number of entries seen in input files.
510 // The total size of input sections.
514 } // End namespace gold.
516 #endif // !defined(GOLD_MERGE_H)