Home | History | Annotate | Download | only in gold
      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