Commit | Line | Data |
---|---|---|
62b01cb5 ILT |
1 | // reduced_debug_output.cc -- output reduced debugging information to save space |
2 | ||
3 | // Copyright 2008 Free Software Foundation, Inc. | |
4 | // Written by Caleb Howe <cshowe@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 | #include "gold.h" | |
24 | ||
25 | #include "parameters.h" | |
26 | #include "options.h" | |
27 | #include "dwarf.h" | |
28 | #include "dwarf_reader.h" | |
29 | #include "reduced_debug_output.h" | |
30 | ||
31 | #include <vector> | |
32 | ||
33 | namespace gold | |
34 | { | |
35 | ||
36 | void | |
37 | write_unsigned_LEB_128(std::vector<unsigned char>* buffer, uint64_t value) | |
38 | { | |
39 | do | |
40 | { | |
41 | unsigned char current_byte = value & 0x7f; | |
42 | value >>= 7; | |
43 | if (value != 0) | |
44 | { | |
45 | current_byte |= 0x80; | |
46 | } | |
47 | buffer->push_back(current_byte); | |
48 | } | |
49 | while (value != 0); | |
50 | } | |
51 | ||
52 | size_t | |
53 | get_length_as_unsigned_LEB_128(uint64_t value) | |
54 | { | |
55 | size_t length = 0; | |
56 | do | |
57 | { | |
58 | unsigned char current_byte = value & 0x7f; | |
59 | value >>= 7; | |
60 | if (value != 0) | |
61 | { | |
62 | current_byte |= 0x80; | |
63 | } | |
64 | length++; | |
65 | } | |
66 | while (value != 0); | |
67 | return length; | |
68 | } | |
69 | ||
70 | template <int valsize> | |
e0ebcf42 | 71 | void insert_into_vector(std::vector<unsigned char>* destination, |
62b01cb5 ILT |
72 | typename elfcpp::Valtype_base<valsize>::Valtype value) |
73 | { | |
e0ebcf42 | 74 | unsigned char buffer[valsize / 8]; |
62b01cb5 | 75 | if (parameters->target().is_big_endian()) |
e0ebcf42 | 76 | elfcpp::Swap_unaligned<valsize, true>::writeval(buffer, value); |
62b01cb5 | 77 | else |
e0ebcf42 ILT |
78 | elfcpp::Swap_unaligned<valsize, false>::writeval(buffer, value); |
79 | destination->insert(destination->end(), buffer, buffer + valsize / 8); | |
62b01cb5 ILT |
80 | } |
81 | ||
82 | template <int valsize> | |
83 | typename elfcpp::Valtype_base<valsize>::Valtype | |
84 | read_from_pointer(unsigned char** source) | |
85 | { | |
86 | typename elfcpp::Valtype_base<valsize>::Valtype return_value; | |
87 | if (parameters->target().is_big_endian()) | |
88 | return_value = elfcpp::Swap_unaligned<valsize, true>::readval(*source); | |
89 | else | |
90 | return_value = elfcpp::Swap_unaligned<valsize, false>::readval(*source); | |
91 | *source += valsize / 8; | |
92 | return return_value; | |
93 | } | |
94 | ||
95 | // Given a pointer to the beginning of a die and the beginning of the associated | |
96 | // abbreviation fills in die_end with the end of the information entry. If | |
97 | // successful returns true. Get_die_end also takes a pointer to the end of the | |
98 | // buffer containing the die. If die_end would be beyond the end of the | |
99 | // buffer, or if an unsupported dwarf form is encountered returns false. | |
100 | bool | |
101 | Output_reduced_debug_info_section::get_die_end( | |
102 | unsigned char* die, unsigned char* abbrev, unsigned char** die_end, | |
103 | unsigned char* buffer_end, int address_size, bool is64) | |
104 | { | |
105 | size_t LEB_size; | |
106 | uint64_t LEB_decoded; | |
107 | for(;;) | |
108 | { | |
109 | uint64_t attribute = read_unsigned_LEB_128(abbrev, &LEB_size); | |
110 | abbrev += LEB_size; | |
111 | elfcpp::DW_FORM form = | |
112 | static_cast<elfcpp::DW_FORM>(read_unsigned_LEB_128(abbrev, | |
113 | &LEB_size)); | |
114 | abbrev += LEB_size; | |
115 | if (!(attribute || form)) | |
116 | break; | |
117 | if (die >= buffer_end) | |
118 | return false; | |
119 | switch(form) | |
120 | { | |
121 | case elfcpp::DW_FORM_null: | |
122 | break; | |
123 | case elfcpp::DW_FORM_strp: | |
124 | die += is64 ? 8 : 4; | |
125 | break; | |
126 | case elfcpp::DW_FORM_addr: | |
127 | case elfcpp::DW_FORM_ref_addr: | |
128 | die += address_size; | |
129 | break; | |
130 | case elfcpp::DW_FORM_block1: | |
131 | die += *die; | |
132 | die += 1; | |
133 | break; | |
134 | case elfcpp::DW_FORM_block2: | |
135 | { | |
136 | uint16_t block_size; | |
137 | block_size = read_from_pointer<16>(&die); | |
138 | die += block_size; | |
139 | break; | |
140 | } | |
141 | case elfcpp::DW_FORM_block4: | |
142 | { | |
143 | uint32_t block_size; | |
144 | block_size = read_from_pointer<32>(&die); | |
145 | die += block_size; | |
146 | break; | |
147 | } | |
148 | case elfcpp::DW_FORM_block: | |
149 | LEB_decoded = read_unsigned_LEB_128(die, &LEB_size); | |
150 | die += (LEB_decoded + LEB_size); | |
151 | break; | |
152 | case elfcpp::DW_FORM_data1: | |
153 | case elfcpp::DW_FORM_ref1: | |
154 | case elfcpp::DW_FORM_flag: | |
155 | die += 1; | |
156 | break; | |
157 | case elfcpp::DW_FORM_data2: | |
158 | case elfcpp::DW_FORM_ref2: | |
159 | die += 2; | |
160 | break; | |
161 | case elfcpp::DW_FORM_data4: | |
162 | case elfcpp::DW_FORM_ref4: | |
163 | die += 4; | |
164 | break; | |
165 | case elfcpp::DW_FORM_data8: | |
166 | case elfcpp::DW_FORM_ref8: | |
167 | die += 8; | |
168 | break; | |
169 | case elfcpp::DW_FORM_ref_udata: | |
170 | case elfcpp::DW_FORM_udata: | |
171 | read_unsigned_LEB_128(die, &LEB_size); | |
172 | die += LEB_size; | |
173 | break; | |
174 | case elfcpp::DW_FORM_string: | |
175 | { | |
176 | size_t length = strlen(reinterpret_cast<char*>(die)); | |
177 | die += length + 1; | |
178 | break; | |
179 | } | |
180 | case elfcpp::DW_FORM_sdata: | |
181 | case elfcpp::DW_FORM_indirect: | |
182 | return false; | |
183 | } | |
184 | } | |
185 | *die_end = die; | |
186 | return true; | |
187 | } | |
188 | ||
189 | void | |
190 | Output_reduced_debug_abbrev_section::set_final_data_size() | |
191 | { | |
192 | if (this->sized_ || this->failed_) | |
193 | return; | |
194 | ||
195 | uint64_t abbrev_number; | |
196 | size_t LEB_size; | |
197 | unsigned char* abbrev_data = this->postprocessing_buffer(); | |
198 | unsigned char* abbrev_end = this->postprocessing_buffer() + | |
199 | this->postprocessing_buffer_size(); | |
200 | this->write_to_postprocessing_buffer(); | |
201 | while(abbrev_data < abbrev_end) | |
202 | { | |
203 | uint64_t abbrev_offset = abbrev_data - this->postprocessing_buffer(); | |
204 | while((abbrev_number = read_unsigned_LEB_128(abbrev_data, &LEB_size))) | |
205 | { | |
206 | if (abbrev_data >= abbrev_end) | |
207 | { | |
208 | failed("Debug abbreviations extend beyond .debug_abbrev " | |
209 | "section; failed to reduce debug abbreviations"); | |
210 | return; | |
211 | } | |
212 | abbrev_data += LEB_size; | |
213 | ||
214 | // Together with the abbreviation number these fields make up | |
215 | // the header for each abbreviation | |
216 | uint64_t abbrev_type = read_unsigned_LEB_128(abbrev_data, &LEB_size); | |
217 | abbrev_data += LEB_size; | |
218 | ||
219 | // This would ordinarily be the has_children field of the | |
220 | // abbreviation. But it's going to be false after reducting the | |
221 | // information, so there's no point in storing it | |
222 | abbrev_data++; | |
223 | ||
224 | // Read to the end of the current abbreviation | |
225 | // This is indicated by two zero unsigned LEBs in a row. We don't | |
226 | // need to parse the data yet, so we just scan through the data | |
227 | // looking for two consecutive 0 bytes indicating the end of the | |
228 | // abbreviation | |
229 | unsigned char* current_abbrev; | |
230 | for (current_abbrev = abbrev_data; | |
231 | current_abbrev[0] || current_abbrev[1]; | |
232 | current_abbrev++) | |
233 | { | |
234 | if (current_abbrev >= abbrev_end) | |
235 | { | |
236 | this->failed(_("Debug abbreviations extend beyond " | |
237 | ".debug_abbrev section; failed to reduce " | |
238 | "debug abbreviations")); | |
239 | return; | |
240 | } | |
241 | } | |
242 | // Account for the two nulls and advance to the start of the | |
243 | // next abbreviation. | |
244 | current_abbrev += 2; | |
245 | ||
246 | // We're eliminating every entry except for compile units, so we | |
247 | // only need to store abbreviations that describe them | |
248 | if (abbrev_type == elfcpp::DW_TAG_compile_unit) | |
249 | { | |
250 | write_unsigned_LEB_128(&this->data_, ++this->abbrev_count_); | |
251 | write_unsigned_LEB_128(&this->data_, abbrev_type); | |
252 | // has_children is false for all entries | |
253 | this->data_.push_back(0); | |
254 | this->abbrev_mapping_[std::make_pair(abbrev_offset, | |
255 | abbrev_number)] = | |
256 | std::make_pair(abbrev_count_, this->data_.size()); | |
257 | this->data_.insert(this->data_.end(), abbrev_data, | |
258 | current_abbrev); | |
259 | } | |
260 | abbrev_data = current_abbrev; | |
261 | } | |
262 | gold_assert(LEB_size == 1); | |
263 | abbrev_data += LEB_size; | |
264 | } | |
265 | // Null terminate the list of abbreviations | |
266 | this->data_.push_back(0); | |
267 | this->set_data_size(data_.size()); | |
268 | this->sized_ = true; | |
269 | } | |
270 | ||
271 | void | |
272 | Output_reduced_debug_abbrev_section::do_write(Output_file* of) | |
273 | { | |
274 | off_t offset = this->offset(); | |
275 | off_t data_size = this->data_size(); | |
276 | unsigned char* view = of->get_output_view(offset, data_size); | |
277 | if (this->failed_) | |
278 | memcpy(view, this->postprocessing_buffer(), | |
279 | this->postprocessing_buffer_size()); | |
280 | else | |
281 | memcpy(view, &this->data_.front(), data_size); | |
282 | of->write_output_view(offset, data_size, view); | |
283 | } | |
284 | ||
285 | // Locates the abbreviation with abbreviation_number abbrev_number in the | |
286 | // abbreviation table at offset abbrev_offset. abbrev_number is updated with | |
287 | // its new abbreviation number and a pointer to the beginning of the | |
288 | // abbreviation is returned. | |
289 | unsigned char* | |
290 | Output_reduced_debug_abbrev_section::get_new_abbrev( | |
291 | uint64_t* abbrev_number, uint64_t abbrev_offset) | |
292 | { | |
293 | set_final_data_size(); | |
294 | std::pair<uint64_t, uint64_t> abbrev_info = | |
295 | this->abbrev_mapping_[std::make_pair(abbrev_offset, *abbrev_number)]; | |
296 | *abbrev_number = abbrev_info.first; | |
297 | return &this->data_[abbrev_info.second]; | |
298 | } | |
299 | ||
300 | void Output_reduced_debug_info_section::set_final_data_size() | |
301 | { | |
302 | if (this->failed_) | |
303 | return; | |
304 | unsigned char* debug_info = this->postprocessing_buffer(); | |
305 | unsigned char* debug_info_end = (this->postprocessing_buffer() | |
306 | + this->postprocessing_buffer_size()); | |
307 | unsigned char* next_compile_unit; | |
308 | this->write_to_postprocessing_buffer(); | |
309 | ||
310 | while (debug_info < debug_info_end) | |
311 | { | |
312 | uint32_t compile_unit_start = read_from_pointer<32>(&debug_info); | |
313 | // The first 4 bytes of each compile unit determine whether or | |
314 | // not we're using dwarf32 or dwarf64. This is not necessarily | |
315 | // related to whether the binary is 32 or 64 bits. | |
316 | if (compile_unit_start == 0xFFFFFFFF) | |
317 | { | |
318 | // Technically the size can be up to 96 bits. Rather than handle | |
319 | // 96/128 bit integers we just truncate the size at 64 bits. | |
320 | if (0 != read_from_pointer<32>(&debug_info)) | |
321 | { | |
322 | this->failed(_("Extremely large compile unit in debug info; " | |
323 | "failed to reduce debug info")); | |
324 | return; | |
325 | } | |
326 | const int dwarf64_header_size = sizeof(uint64_t) + sizeof(uint16_t) + | |
327 | sizeof(uint64_t) + sizeof(uint8_t); | |
328 | if (debug_info + dwarf64_header_size >= debug_info_end) | |
329 | { | |
330 | this->failed(_("Debug info extends beyond .debug_info section;" | |
331 | "failed to reduce debug info")); | |
332 | return; | |
333 | } | |
334 | ||
335 | uint64_t compile_unit_size = read_from_pointer<64>(&debug_info); | |
336 | next_compile_unit = debug_info + compile_unit_size; | |
337 | uint16_t version = read_from_pointer<16>(&debug_info); | |
338 | uint64_t abbrev_offset = read_from_pointer<64>(&debug_info); | |
339 | uint8_t address_size = read_from_pointer<8>(&debug_info); | |
340 | size_t LEB_size; | |
341 | uint64_t abbreviation_number = read_unsigned_LEB_128(debug_info, | |
342 | &LEB_size); | |
343 | debug_info += LEB_size; | |
344 | unsigned char* die_abbrev = this->associated_abbrev_->get_new_abbrev( | |
345 | &abbreviation_number, abbrev_offset); | |
346 | unsigned char* die_end; | |
347 | if (!this->get_die_end(debug_info, die_abbrev, &die_end, | |
348 | debug_info_end, address_size, true)) | |
349 | { | |
350 | this->failed(_("Invalid DIE in debug info; " | |
351 | "failed to reduce debug info")); | |
352 | return; | |
353 | } | |
354 | ||
e0ebcf42 ILT |
355 | insert_into_vector<32>(&this->data_, 0xFFFFFFFF); |
356 | insert_into_vector<32>(&this->data_, 0); | |
357 | insert_into_vector<64>( | |
62b01cb5 ILT |
358 | &this->data_, |
359 | (11 + get_length_as_unsigned_LEB_128(abbreviation_number) | |
360 | + die_end - debug_info)); | |
e0ebcf42 ILT |
361 | insert_into_vector<16>(&this->data_, version); |
362 | insert_into_vector<64>(&this->data_, 0); | |
363 | insert_into_vector<8>(&this->data_, address_size); | |
62b01cb5 ILT |
364 | write_unsigned_LEB_128(&this->data_, abbreviation_number); |
365 | this->data_.insert(this->data_.end(), debug_info, die_end); | |
366 | } | |
367 | else | |
368 | { | |
369 | const int dwarf32_header_size = | |
370 | sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t); | |
371 | if (debug_info + dwarf32_header_size >= debug_info_end) | |
372 | { | |
373 | this->failed(_("Debug info extends beyond .debug_info section; " | |
374 | "failed to reduce debug info")); | |
375 | return; | |
376 | } | |
377 | uint32_t compile_unit_size = compile_unit_start; | |
378 | next_compile_unit = debug_info + compile_unit_size; | |
379 | uint16_t version = read_from_pointer<16>(&debug_info); | |
380 | uint32_t abbrev_offset = read_from_pointer<32>(&debug_info); | |
381 | uint8_t address_size = read_from_pointer<8>(&debug_info); | |
382 | size_t LEB_size; | |
383 | uint64_t abbreviation_number = read_unsigned_LEB_128(debug_info, | |
384 | &LEB_size); | |
385 | debug_info += LEB_size; | |
386 | unsigned char* die_abbrev = this->associated_abbrev_->get_new_abbrev( | |
387 | &abbreviation_number, abbrev_offset); | |
388 | unsigned char* die_end; | |
389 | if (!this->get_die_end(debug_info, die_abbrev, &die_end, | |
390 | debug_info_end, address_size, false)) | |
391 | { | |
392 | this->failed(_("Invalid DIE in debug info; " | |
393 | "failed to reduce debug info")); | |
394 | return; | |
395 | } | |
396 | ||
e0ebcf42 | 397 | insert_into_vector<32>( |
62b01cb5 ILT |
398 | &this->data_, |
399 | (7 + get_length_as_unsigned_LEB_128(abbreviation_number) | |
400 | + die_end - debug_info)); | |
e0ebcf42 ILT |
401 | insert_into_vector<16>(&this->data_, version); |
402 | insert_into_vector<32>(&this->data_, 0); | |
403 | insert_into_vector<8>(&this->data_, address_size); | |
62b01cb5 ILT |
404 | write_unsigned_LEB_128(&this->data_, abbreviation_number); |
405 | this->data_.insert(this->data_.end(), debug_info, die_end); | |
406 | } | |
407 | debug_info = next_compile_unit; | |
408 | } | |
409 | this->set_data_size(data_.size()); | |
410 | } | |
411 | ||
412 | void Output_reduced_debug_info_section::do_write(Output_file* of) | |
413 | { | |
414 | off_t offset = this->offset(); | |
415 | off_t data_size = this->data_size(); | |
416 | unsigned char* view = of->get_output_view(offset, data_size); | |
417 | if (this->failed_) | |
418 | memcpy(view, this->postprocessing_buffer(), | |
419 | this->postprocessing_buffer_size()); | |
420 | else | |
421 | memcpy(view, &this->data_.front(), data_size); | |
422 | of->write_output_view(offset, data_size, view); | |
423 | } | |
424 | ||
425 | } // End namespace gold. |