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