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 typedef std::vector<DexFile::PositionInfo> PositionInfos;
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