1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ART_COMPILER_DEBUG_ELF_DEBUG_LINE_WRITER_H_ 18 #define ART_COMPILER_DEBUG_ELF_DEBUG_LINE_WRITER_H_ 19 20 #include <unordered_set> 21 #include <vector> 22 23 #include "debug/elf_compilation_unit.h" 24 #include "debug/src_map_elem.h" 25 #include "dex/dex_file-inl.h" 26 #include "dwarf/debug_line_opcode_writer.h" 27 #include "dwarf/headers.h" 28 #include "elf/elf_builder.h" 29 #include "oat_file.h" 30 #include "stack_map.h" 31 32 namespace art { 33 namespace debug { 34 35 using PositionInfos = std::vector<DexFile::PositionInfo>; 36 37 template<typename ElfTypes> 38 class ElfDebugLineWriter { 39 using Elf_Addr = typename ElfTypes::Addr; 40 41 public: ElfDebugLineWriter(ElfBuilder<ElfTypes> * builder)42 explicit ElfDebugLineWriter(ElfBuilder<ElfTypes>* builder) : builder_(builder) { 43 } 44 Start()45 void Start() { 46 builder_->GetDebugLine()->Start(); 47 } 48 49 // Write line table for given set of methods. 50 // Returns the number of bytes written. WriteCompilationUnit(ElfCompilationUnit & compilation_unit)51 size_t WriteCompilationUnit(ElfCompilationUnit& compilation_unit) { 52 const InstructionSet isa = builder_->GetIsa(); 53 const bool is64bit = Is64BitInstructionSet(isa); 54 const Elf_Addr base_address = compilation_unit.is_code_address_text_relative 55 ? builder_->GetText()->GetAddress() 56 : 0; 57 58 compilation_unit.debug_line_offset = builder_->GetDebugLine()->GetPosition(); 59 60 std::vector<dwarf::FileEntry> files; 61 std::unordered_map<std::string, size_t> files_map; 62 std::vector<std::string> directories; 63 std::unordered_map<std::string, size_t> directories_map; 64 int code_factor_bits_ = 0; 65 int dwarf_isa = -1; 66 switch (isa) { 67 case InstructionSet::kArm: // arm actually means thumb2. 68 case InstructionSet::kThumb2: 69 code_factor_bits_ = 1; // 16-bit instuctions 70 dwarf_isa = 1; // DW_ISA_ARM_thumb. 71 break; 72 case InstructionSet::kArm64: 73 code_factor_bits_ = 2; // 32-bit instructions 74 break; 75 case InstructionSet::kNone: 76 case InstructionSet::kX86: 77 case InstructionSet::kX86_64: 78 break; 79 } 80 std::unordered_set<uint64_t> seen_addresses(compilation_unit.methods.size()); 81 dwarf::DebugLineOpCodeWriter<> opcodes(is64bit, code_factor_bits_); 82 for (const MethodDebugInfo* mi : compilation_unit.methods) { 83 // Ignore function if we have already generated line table for the same address. 84 // It would confuse the debugger and the DWARF specification forbids it. 85 // We allow the line table for method to be replicated in different compilation unit. 86 // This ensures that each compilation unit contains line table for all its methods. 87 if (!seen_addresses.insert(mi->code_address).second) { 88 continue; 89 } 90 91 uint32_t prologue_end = std::numeric_limits<uint32_t>::max(); 92 std::vector<SrcMapElem> pc2dex_map; 93 if (mi->code_info != nullptr) { 94 // Use stack maps to create mapping table from pc to dex. 95 const CodeInfo code_info(mi->code_info); 96 pc2dex_map.reserve(code_info.GetNumberOfStackMaps()); 97 for (StackMap stack_map : code_info.GetStackMaps()) { 98 const uint32_t pc = stack_map.GetNativePcOffset(isa); 99 const int32_t dex = stack_map.GetDexPc(); 100 pc2dex_map.push_back({pc, dex}); 101 if (stack_map.HasDexRegisterMap()) { 102 // Guess that the first map with local variables is the end of prologue. 103 prologue_end = std::min(prologue_end, pc); 104 } 105 } 106 std::sort(pc2dex_map.begin(), pc2dex_map.end()); 107 } 108 109 if (pc2dex_map.empty()) { 110 continue; 111 } 112 113 // Compensate for compiler's off-by-one-instruction error. 114 // 115 // The compiler generates stackmap with PC *after* the branch instruction 116 // (because this is the PC which is easier to obtain when unwinding). 117 // 118 // However, the debugger is more clever and it will ask us for line-number 119 // mapping at the location of the branch instruction (since the following 120 // instruction could belong to other line, this is the correct thing to do). 121 // 122 // So we really want to just decrement the PC by one instruction so that the 123 // branch instruction is covered as well. However, we do not know the size 124 // of the previous instruction, and we can not subtract just a fixed amount 125 // (the debugger would trust us that the PC is valid; it might try to set 126 // breakpoint there at some point, and setting breakpoint in mid-instruction 127 // would make the process crash in spectacular way). 128 // 129 // Therefore, we say that the PC which the compiler gave us for the stackmap 130 // is the end of its associated address range, and we use the PC from the 131 // previous stack map as the start of the range. This ensures that the PC is 132 // valid and that the branch instruction is covered. 133 // 134 // This ensures we have correct line number mapping at call sites (which is 135 // important for backtraces), but there is nothing we can do for non-call 136 // sites (so stepping through optimized code in debugger is not possible). 137 // 138 // We do not adjust the stackmaps if the code was compiled as debuggable. 139 // In that case, the stackmaps should accurately cover all instructions. 140 if (!mi->is_native_debuggable) { 141 for (size_t i = pc2dex_map.size() - 1; i > 0; --i) { 142 pc2dex_map[i].from_ = pc2dex_map[i - 1].from_; 143 } 144 pc2dex_map[0].from_ = 0; 145 } 146 147 Elf_Addr method_address = base_address + mi->code_address; 148 149 PositionInfos dex2line_map; 150 const DexFile* dex = mi->dex_file; 151 DCHECK(dex != nullptr); 152 CodeItemDebugInfoAccessor accessor(*dex, mi->code_item, mi->dex_method_index); 153 if (!accessor.DecodeDebugPositionInfo( 154 [&](const DexFile::PositionInfo& entry) { 155 dex2line_map.push_back(entry); 156 return false; 157 })) { 158 continue; 159 } 160 161 if (dex2line_map.empty()) { 162 continue; 163 } 164 165 opcodes.SetAddress(method_address); 166 if (dwarf_isa != -1) { 167 opcodes.SetISA(dwarf_isa); 168 } 169 170 // Get and deduplicate directory and filename. 171 int file_index = 0; // 0 - primary source file of the compilation. 172 auto& dex_class_def = dex->GetClassDef(mi->class_def_index); 173 const char* source_file = dex->GetSourceFile(dex_class_def); 174 if (source_file != nullptr) { 175 std::string file_name(source_file); 176 size_t file_name_slash = file_name.find_last_of('/'); 177 std::string class_name(dex->GetClassDescriptor(dex_class_def)); 178 size_t class_name_slash = class_name.find_last_of('/'); 179 std::string full_path(file_name); 180 181 // Guess directory from package name. 182 int directory_index = 0; // 0 - current directory of the compilation. 183 if (file_name_slash == std::string::npos && // Just filename. 184 class_name.front() == 'L' && // Type descriptor for a class. 185 class_name_slash != std::string::npos) { // Has package name. 186 std::string package_name = class_name.substr(1, class_name_slash - 1); 187 auto it = directories_map.find(package_name); 188 if (it == directories_map.end()) { 189 directory_index = 1 + directories.size(); 190 directories_map.emplace(package_name, directory_index); 191 directories.push_back(package_name); 192 } else { 193 directory_index = it->second; 194 } 195 full_path = package_name + "/" + file_name; 196 } 197 198 // Add file entry. 199 auto it2 = files_map.find(full_path); 200 if (it2 == files_map.end()) { 201 file_index = 1 + files.size(); 202 files_map.emplace(full_path, file_index); 203 files.push_back(dwarf::FileEntry { 204 file_name, 205 directory_index, 206 0, // Modification time - NA. 207 0, // File size - NA. 208 }); 209 } else { 210 file_index = it2->second; 211 } 212 } 213 opcodes.SetFile(file_index); 214 215 // Generate mapping opcodes from PC to Java lines. 216 if (file_index != 0) { 217 // If the method was not compiled as native-debuggable, we still generate all available 218 // lines, but we try to prevent the debugger from stepping and setting breakpoints since 219 // the information is too inaccurate for that (breakpoints would be set after the calls). 220 const bool default_is_stmt = mi->is_native_debuggable; 221 bool first = true; 222 for (SrcMapElem pc2dex : pc2dex_map) { 223 uint32_t pc = pc2dex.from_; 224 int dex_pc = pc2dex.to_; 225 // Find mapping with address with is greater than our dex pc; then go back one step. 226 auto dex2line = std::upper_bound( 227 dex2line_map.begin(), 228 dex2line_map.end(), 229 dex_pc, 230 [](uint32_t address, const DexFile::PositionInfo& entry) { 231 return address < entry.address_; 232 }); 233 // Look for first valid mapping after the prologue. 234 if (dex2line != dex2line_map.begin() && pc >= prologue_end) { 235 int line = (--dex2line)->line_; 236 if (first) { 237 first = false; 238 if (pc > 0) { 239 // Assume that any preceding code is prologue. 240 int first_line = dex2line_map.front().line_; 241 // Prologue is not a sensible place for a breakpoint. 242 opcodes.SetIsStmt(false); 243 opcodes.AddRow(method_address, first_line); 244 opcodes.SetPrologueEnd(); 245 } 246 opcodes.SetIsStmt(default_is_stmt); 247 opcodes.AddRow(method_address + pc, line); 248 } else if (line != opcodes.CurrentLine()) { 249 opcodes.SetIsStmt(default_is_stmt); 250 opcodes.AddRow(method_address + pc, line); 251 } 252 } 253 } 254 } else { 255 // line 0 - instruction cannot be attributed to any source line. 256 opcodes.AddRow(method_address, 0); 257 } 258 259 opcodes.AdvancePC(method_address + mi->code_size); 260 opcodes.EndSequence(); 261 } 262 std::vector<uint8_t> buffer; 263 buffer.reserve(opcodes.data()->size() + KB); 264 WriteDebugLineTable(directories, files, opcodes, &buffer); 265 builder_->GetDebugLine()->WriteFully(buffer.data(), buffer.size()); 266 return buffer.size(); 267 } 268 End()269 void End() { 270 builder_->GetDebugLine()->End(); 271 } 272 273 private: 274 ElfBuilder<ElfTypes>* builder_; 275 }; 276 277 } // namespace debug 278 } // namespace art 279 280 #endif // ART_COMPILER_DEBUG_ELF_DEBUG_LINE_WRITER_H_ 281 282