1 // reduced_debug_output.cc -- output reduced debugging information to save space
3 // Copyright 2008, 2010 Free Software Foundation, Inc.
4 // Written by Caleb Howe <cshowe@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.
25 #include "parameters.h"
28 #include "dwarf_reader.h"
29 #include "reduced_debug_output.h"
30 #include "int_encoding.h"
37 // Given a pointer to the beginning of a die and the beginning of the associated
38 // abbreviation fills in die_end with the end of the information entry. If
39 // successful returns true. Get_die_end also takes a pointer to the end of the
40 // buffer containing the die. If die_end would be beyond the end of the
41 // buffer, or if an unsupported dwarf form is encountered returns false.
43 Output_reduced_debug_info_section::get_die_end(
44 unsigned char* die
, unsigned char* abbrev
, unsigned char** die_end
,
45 unsigned char* buffer_end
, int address_size
, bool is64
)
51 uint64_t attribute
= read_unsigned_LEB_128(abbrev
, &LEB_size
);
53 elfcpp::DW_FORM form
=
54 static_cast<elfcpp::DW_FORM
>(read_unsigned_LEB_128(abbrev
,
57 if (!(attribute
|| form
))
59 if (die
>= buffer_end
)
63 case elfcpp::DW_FORM_null
:
64 case elfcpp::DW_FORM_flag_present
:
66 case elfcpp::DW_FORM_strp
:
67 case elfcpp::DW_FORM_sec_offset
:
70 case elfcpp::DW_FORM_addr
:
71 case elfcpp::DW_FORM_ref_addr
:
74 case elfcpp::DW_FORM_block1
:
78 case elfcpp::DW_FORM_block2
:
81 block_size
= read_from_pointer
<16>(&die
);
85 case elfcpp::DW_FORM_block4
:
88 block_size
= read_from_pointer
<32>(&die
);
92 case elfcpp::DW_FORM_block
:
93 case elfcpp::DW_FORM_exprloc
:
94 LEB_decoded
= read_unsigned_LEB_128(die
, &LEB_size
);
95 die
+= (LEB_decoded
+ LEB_size
);
97 case elfcpp::DW_FORM_data1
:
98 case elfcpp::DW_FORM_ref1
:
99 case elfcpp::DW_FORM_flag
:
102 case elfcpp::DW_FORM_data2
:
103 case elfcpp::DW_FORM_ref2
:
106 case elfcpp::DW_FORM_data4
:
107 case elfcpp::DW_FORM_ref4
:
110 case elfcpp::DW_FORM_data8
:
111 case elfcpp::DW_FORM_ref8
:
112 case elfcpp::DW_FORM_ref_sig8
:
115 case elfcpp::DW_FORM_ref_udata
:
116 case elfcpp::DW_FORM_udata
:
117 read_unsigned_LEB_128(die
, &LEB_size
);
120 case elfcpp::DW_FORM_sdata
:
121 read_signed_LEB_128(die
, &LEB_size
);
124 case elfcpp::DW_FORM_string
:
126 size_t length
= strlen(reinterpret_cast<char*>(die
));
130 case elfcpp::DW_FORM_indirect
:
131 case elfcpp::DW_FORM_GNU_ref_index
:
132 case elfcpp::DW_FORM_GNU_addr_index
:
133 case elfcpp::DW_FORM_GNU_str_index
:
142 Output_reduced_debug_abbrev_section::set_final_data_size()
144 if (this->sized_
|| this->failed_
)
147 uint64_t abbrev_number
;
149 unsigned char* abbrev_data
= this->postprocessing_buffer();
150 unsigned char* abbrev_end
= this->postprocessing_buffer() +
151 this->postprocessing_buffer_size();
152 this->write_to_postprocessing_buffer();
153 while(abbrev_data
< abbrev_end
)
155 uint64_t abbrev_offset
= abbrev_data
- this->postprocessing_buffer();
156 while((abbrev_number
= read_unsigned_LEB_128(abbrev_data
, &LEB_size
)))
158 if (abbrev_data
>= abbrev_end
)
160 failed("Debug abbreviations extend beyond .debug_abbrev "
161 "section; failed to reduce debug abbreviations");
164 abbrev_data
+= LEB_size
;
166 // Together with the abbreviation number these fields make up
167 // the header for each abbreviation.
168 uint64_t abbrev_type
= read_unsigned_LEB_128(abbrev_data
, &LEB_size
);
169 abbrev_data
+= LEB_size
;
171 // This would ordinarily be the has_children field of the
172 // abbreviation. But it's going to be false after reducing the
173 // information, so there's no point in storing it.
176 // Read to the end of the current abbreviation.
177 // This is indicated by two zero unsigned LEBs in a row. We don't
178 // need to parse the data yet, so we just scan through the data
179 // looking for two consecutive 0 bytes indicating the end of the
181 unsigned char* current_abbrev
;
182 for (current_abbrev
= abbrev_data
;
183 current_abbrev
[0] || current_abbrev
[1];
186 if (current_abbrev
>= abbrev_end
)
188 this->failed(_("Debug abbreviations extend beyond "
189 ".debug_abbrev section; failed to reduce "
190 "debug abbreviations"));
194 // Account for the two nulls and advance to the start of the
195 // next abbreviation.
198 // We're eliminating every entry except for compile units, so we
199 // only need to store abbreviations that describe them
200 if (abbrev_type
== elfcpp::DW_TAG_compile_unit
)
202 write_unsigned_LEB_128(&this->data_
, ++this->abbrev_count_
);
203 write_unsigned_LEB_128(&this->data_
, abbrev_type
);
204 // has_children is false for all entries
205 this->data_
.push_back(0);
206 this->abbrev_mapping_
[std::make_pair(abbrev_offset
,
208 std::make_pair(abbrev_count_
, this->data_
.size());
209 this->data_
.insert(this->data_
.end(), abbrev_data
,
212 abbrev_data
= current_abbrev
;
214 gold_assert(LEB_size
== 1);
215 abbrev_data
+= LEB_size
;
217 // Null terminate the list of abbreviations
218 this->data_
.push_back(0);
219 this->set_data_size(data_
.size());
224 Output_reduced_debug_abbrev_section::do_write(Output_file
* of
)
226 off_t offset
= this->offset();
227 off_t data_size
= this->data_size();
228 unsigned char* view
= of
->get_output_view(offset
, data_size
);
230 memcpy(view
, this->postprocessing_buffer(),
231 this->postprocessing_buffer_size());
233 memcpy(view
, &this->data_
.front(), data_size
);
234 of
->write_output_view(offset
, data_size
, view
);
237 // Locates the abbreviation with abbreviation_number abbrev_number in the
238 // abbreviation table at offset abbrev_offset. abbrev_number is updated with
239 // its new abbreviation number and a pointer to the beginning of the
240 // abbreviation is returned.
242 Output_reduced_debug_abbrev_section::get_new_abbrev(
243 uint64_t* abbrev_number
, uint64_t abbrev_offset
)
245 set_final_data_size();
246 std::pair
<uint64_t, uint64_t> abbrev_info
=
247 this->abbrev_mapping_
[std::make_pair(abbrev_offset
, *abbrev_number
)];
248 *abbrev_number
= abbrev_info
.first
;
249 return &this->data_
[abbrev_info
.second
];
252 void Output_reduced_debug_info_section::set_final_data_size()
256 unsigned char* debug_info
= this->postprocessing_buffer();
257 unsigned char* debug_info_end
= (this->postprocessing_buffer()
258 + this->postprocessing_buffer_size());
259 unsigned char* next_compile_unit
;
260 this->write_to_postprocessing_buffer();
262 while (debug_info
< debug_info_end
)
264 uint32_t compile_unit_start
= read_from_pointer
<32>(&debug_info
);
265 // The first 4 bytes of each compile unit determine whether or
266 // not we're using dwarf32 or dwarf64. This is not necessarily
267 // related to whether the binary is 32 or 64 bits.
268 if (compile_unit_start
== 0xFFFFFFFF)
270 // Technically the size can be up to 96 bits. Rather than handle
271 // 96/128 bit integers we just truncate the size at 64 bits.
272 if (0 != read_from_pointer
<32>(&debug_info
))
274 this->failed(_("Extremely large compile unit in debug info; "
275 "failed to reduce debug info"));
278 const int dwarf64_header_size
= sizeof(uint64_t) + sizeof(uint16_t) +
279 sizeof(uint64_t) + sizeof(uint8_t);
280 if (debug_info
+ dwarf64_header_size
>= debug_info_end
)
282 this->failed(_("Debug info extends beyond .debug_info section;"
283 "failed to reduce debug info"));
287 uint64_t compile_unit_size
= read_from_pointer
<64>(&debug_info
);
288 next_compile_unit
= debug_info
+ compile_unit_size
;
289 uint16_t version
= read_from_pointer
<16>(&debug_info
);
290 uint64_t abbrev_offset
= read_from_pointer
<64>(&debug_info
);
291 uint8_t address_size
= read_from_pointer
<8>(&debug_info
);
293 uint64_t abbreviation_number
= read_unsigned_LEB_128(debug_info
,
295 debug_info
+= LEB_size
;
296 unsigned char* die_abbrev
= this->associated_abbrev_
->get_new_abbrev(
297 &abbreviation_number
, abbrev_offset
);
298 unsigned char* die_end
;
299 if (!this->get_die_end(debug_info
, die_abbrev
, &die_end
,
300 debug_info_end
, address_size
, true))
302 this->failed(_("Invalid DIE in debug info; "
303 "failed to reduce debug info"));
307 insert_into_vector
<32>(&this->data_
, 0xFFFFFFFF);
308 insert_into_vector
<32>(&this->data_
, 0);
309 insert_into_vector
<64>(
311 (11 + get_length_as_unsigned_LEB_128(abbreviation_number
)
312 + die_end
- debug_info
));
313 insert_into_vector
<16>(&this->data_
, version
);
314 insert_into_vector
<64>(&this->data_
, 0);
315 insert_into_vector
<8>(&this->data_
, address_size
);
316 write_unsigned_LEB_128(&this->data_
, abbreviation_number
);
317 this->data_
.insert(this->data_
.end(), debug_info
, die_end
);
321 const int dwarf32_header_size
=
322 sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
323 if (debug_info
+ dwarf32_header_size
>= debug_info_end
)
325 this->failed(_("Debug info extends beyond .debug_info section; "
326 "failed to reduce debug info"));
329 uint32_t compile_unit_size
= compile_unit_start
;
330 next_compile_unit
= debug_info
+ compile_unit_size
;
331 uint16_t version
= read_from_pointer
<16>(&debug_info
);
332 uint32_t abbrev_offset
= read_from_pointer
<32>(&debug_info
);
333 uint8_t address_size
= read_from_pointer
<8>(&debug_info
);
335 uint64_t abbreviation_number
= read_unsigned_LEB_128(debug_info
,
337 debug_info
+= LEB_size
;
338 unsigned char* die_abbrev
= this->associated_abbrev_
->get_new_abbrev(
339 &abbreviation_number
, abbrev_offset
);
340 unsigned char* die_end
;
341 if (!this->get_die_end(debug_info
, die_abbrev
, &die_end
,
342 debug_info_end
, address_size
, false))
344 this->failed(_("Invalid DIE in debug info; "
345 "failed to reduce debug info"));
349 insert_into_vector
<32>(
351 (7 + get_length_as_unsigned_LEB_128(abbreviation_number
)
352 + die_end
- debug_info
));
353 insert_into_vector
<16>(&this->data_
, version
);
354 insert_into_vector
<32>(&this->data_
, 0);
355 insert_into_vector
<8>(&this->data_
, address_size
);
356 write_unsigned_LEB_128(&this->data_
, abbreviation_number
);
357 this->data_
.insert(this->data_
.end(), debug_info
, die_end
);
359 debug_info
= next_compile_unit
;
361 this->set_data_size(data_
.size());
364 void Output_reduced_debug_info_section::do_write(Output_file
* of
)
366 off_t offset
= this->offset();
367 off_t data_size
= this->data_size();
368 unsigned char* view
= of
->get_output_view(offset
, data_size
);
370 memcpy(view
, this->postprocessing_buffer(),
371 this->postprocessing_buffer_size());
373 memcpy(view
, &this->data_
.front(), data_size
);
374 of
->write_output_view(offset
, data_size
, view
);
377 } // End namespace gold.