| 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> |
| 71 | void insert_into_vector(std::vector<unsigned char>* destination, |
| 72 | typename elfcpp::Valtype_base<valsize>::Valtype value) |
| 73 | { |
| 74 | unsigned char buffer[valsize / 8]; |
| 75 | if (parameters->target().is_big_endian()) |
| 76 | elfcpp::Swap_unaligned<valsize, true>::writeval(buffer, value); |
| 77 | else |
| 78 | elfcpp::Swap_unaligned<valsize, false>::writeval(buffer, value); |
| 79 | destination->insert(destination->end(), buffer, buffer + valsize / 8); |
| 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 | |
| 355 | insert_into_vector<32>(&this->data_, 0xFFFFFFFF); |
| 356 | insert_into_vector<32>(&this->data_, 0); |
| 357 | insert_into_vector<64>( |
| 358 | &this->data_, |
| 359 | (11 + get_length_as_unsigned_LEB_128(abbreviation_number) |
| 360 | + die_end - debug_info)); |
| 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); |
| 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 | |
| 397 | insert_into_vector<32>( |
| 398 | &this->data_, |
| 399 | (7 + get_length_as_unsigned_LEB_128(abbreviation_number) |
| 400 | + die_end - debug_info)); |
| 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); |
| 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. |