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