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