DebugInfo.cpp 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467
  1. /*
  2. * Copyright (c) 2020-2021, Itamar S. <itamar8910@gmail.com>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include "DebugInfo.h"
  7. #include <AK/Debug.h>
  8. #include <AK/LexicalPath.h>
  9. #include <AK/MemoryStream.h>
  10. #include <AK/QuickSort.h>
  11. #include <LibDebug/Dwarf/CompilationUnit.h>
  12. #include <LibDebug/Dwarf/DwarfInfo.h>
  13. #include <LibDebug/Dwarf/Expression.h>
  14. namespace Debug {
  15. DebugInfo::DebugInfo(ELF::Image const& elf, String source_root, FlatPtr base_address)
  16. : m_elf(elf)
  17. , m_source_root(move(source_root))
  18. , m_base_address(base_address)
  19. , m_dwarf_info(m_elf)
  20. {
  21. prepare_variable_scopes();
  22. prepare_lines();
  23. }
  24. void DebugInfo::prepare_variable_scopes()
  25. {
  26. m_dwarf_info.for_each_compilation_unit([&](Dwarf::CompilationUnit const& unit) {
  27. auto root = unit.root_die();
  28. parse_scopes_impl(root);
  29. });
  30. }
  31. void DebugInfo::parse_scopes_impl(Dwarf::DIE const& die)
  32. {
  33. die.for_each_child([&](Dwarf::DIE const& child) {
  34. if (child.is_null())
  35. return;
  36. if (!(child.tag() == Dwarf::EntryTag::SubProgram || child.tag() == Dwarf::EntryTag::LexicalBlock))
  37. return;
  38. if (child.get_attribute(Dwarf::Attribute::Inline).has_value()) {
  39. dbgln_if(SPAM_DEBUG, "DWARF inlined functions are not supported");
  40. return;
  41. }
  42. if (child.get_attribute(Dwarf::Attribute::Ranges).has_value()) {
  43. dbgln_if(SPAM_DEBUG, "DWARF ranges are not supported");
  44. return;
  45. }
  46. auto name = child.get_attribute(Dwarf::Attribute::Name);
  47. VariablesScope scope {};
  48. scope.is_function = (child.tag() == Dwarf::EntryTag::SubProgram);
  49. if (name.has_value())
  50. scope.name = name.value().as_string();
  51. if (!child.get_attribute(Dwarf::Attribute::LowPc).has_value()) {
  52. dbgln_if(SPAM_DEBUG, "DWARF: Couldn't find attribute LowPc for scope");
  53. return;
  54. }
  55. scope.address_low = child.get_attribute(Dwarf::Attribute::LowPc).value().as_addr();
  56. auto high_pc = child.get_attribute(Dwarf::Attribute::HighPc);
  57. if (high_pc->type() == Dwarf::AttributeValue::Type::Address)
  58. scope.address_high = high_pc->as_addr();
  59. else
  60. scope.address_high = scope.address_low + high_pc->as_unsigned();
  61. child.for_each_child([&](Dwarf::DIE const& variable_entry) {
  62. if (!(variable_entry.tag() == Dwarf::EntryTag::Variable
  63. || variable_entry.tag() == Dwarf::EntryTag::FormalParameter))
  64. return;
  65. scope.dies_of_variables.append(variable_entry);
  66. });
  67. m_scopes.append(scope);
  68. parse_scopes_impl(child);
  69. });
  70. }
  71. void DebugInfo::prepare_lines()
  72. {
  73. Vector<Dwarf::LineProgram::LineInfo> all_lines;
  74. m_dwarf_info.for_each_compilation_unit([&all_lines](Dwarf::CompilationUnit const& unit) {
  75. all_lines.extend(unit.line_program().lines());
  76. });
  77. HashMap<FlyString, Optional<String>> memoized_full_paths;
  78. auto compute_full_path = [&](FlyString const& file_path) -> Optional<String> {
  79. if (file_path.view().contains("Toolchain/"sv) || file_path.view().contains("libgcc"sv))
  80. return {};
  81. if (file_path.view().starts_with("./"sv) && !m_source_root.is_null())
  82. return LexicalPath::join(m_source_root, file_path).string();
  83. if (auto index_of_serenity_slash = file_path.view().find("serenity/"sv); index_of_serenity_slash.has_value()) {
  84. auto start_index = index_of_serenity_slash.value() + "serenity/"sv.length();
  85. return file_path.view().substring_view(start_index, file_path.length() - start_index);
  86. }
  87. return file_path;
  88. };
  89. m_sorted_lines.ensure_capacity(all_lines.size());
  90. for (auto const& line_info : all_lines) {
  91. auto maybe_full_path = memoized_full_paths.ensure(line_info.file, [&] { return compute_full_path(line_info.file); });
  92. if (!maybe_full_path.has_value())
  93. continue;
  94. m_sorted_lines.unchecked_append({ line_info.address, maybe_full_path.release_value(), line_info.line });
  95. }
  96. quick_sort(m_sorted_lines, [](auto& a, auto& b) {
  97. return a.address < b.address;
  98. });
  99. }
  100. Optional<DebugInfo::SourcePosition> DebugInfo::get_source_position(FlatPtr target_address) const
  101. {
  102. if (m_sorted_lines.is_empty())
  103. return {};
  104. if (target_address < m_sorted_lines[0].address)
  105. return {};
  106. // TODO: We can do a binary search here
  107. for (size_t i = 0; i < m_sorted_lines.size() - 1; ++i) {
  108. if (m_sorted_lines[i + 1].address > target_address) {
  109. return SourcePosition::from_line_info(m_sorted_lines[i]);
  110. }
  111. }
  112. return {};
  113. }
  114. Optional<DebugInfo::SourcePositionAndAddress> DebugInfo::get_address_from_source_position(String const& file, size_t line) const
  115. {
  116. String file_path = file;
  117. if (!file_path.starts_with('/'))
  118. file_path = String::formatted("/{}", file_path);
  119. constexpr auto SERENITY_LIBS_PREFIX = "/usr/src/serenity"sv;
  120. if (file.starts_with(SERENITY_LIBS_PREFIX)) {
  121. size_t file_prefix_offset = SERENITY_LIBS_PREFIX.length() + 1;
  122. file_path = file.substring(file_prefix_offset, file.length() - file_prefix_offset);
  123. file_path = String::formatted("../{}", file_path);
  124. }
  125. Optional<SourcePositionAndAddress> result;
  126. for (auto const& line_entry : m_sorted_lines) {
  127. if (!line_entry.file.ends_with(file_path))
  128. continue;
  129. if (line_entry.line > line)
  130. continue;
  131. // We look for the source position that is closest to the desired position, and is not after it.
  132. // For example, get_address_of_source_position("main.cpp", 73) could return the address for an instruction whose location is ("main.cpp", 72)
  133. // as there might not be an instruction mapped for "main.cpp", 73.
  134. if (!result.has_value() || (line_entry.line > result.value().line)) {
  135. result = SourcePositionAndAddress { line_entry.file, line_entry.line, line_entry.address };
  136. }
  137. }
  138. return result;
  139. }
  140. NonnullOwnPtrVector<DebugInfo::VariableInfo> DebugInfo::get_variables_in_current_scope(PtraceRegisters const& regs) const
  141. {
  142. NonnullOwnPtrVector<DebugInfo::VariableInfo> variables;
  143. // TODO: We can store the scopes in a better data structure
  144. for (auto const& scope : m_scopes) {
  145. FlatPtr ip;
  146. #if ARCH(I386)
  147. ip = regs.eip;
  148. #elif ARCH(X86_64)
  149. ip = regs.rip;
  150. #elif ARCH(AARCH64)
  151. TODO_AARCH64();
  152. #else
  153. # error Unknown architecture
  154. #endif
  155. if (ip - m_base_address < scope.address_low || ip - m_base_address >= scope.address_high)
  156. continue;
  157. for (auto const& die_entry : scope.dies_of_variables) {
  158. auto variable_info = create_variable_info(die_entry, regs);
  159. if (!variable_info)
  160. continue;
  161. variables.append(variable_info.release_nonnull());
  162. }
  163. }
  164. return variables;
  165. }
  166. static Optional<Dwarf::DIE> parse_variable_type_die(Dwarf::DIE const& variable_die, DebugInfo::VariableInfo& variable_info)
  167. {
  168. auto type_die_offset = variable_die.get_attribute(Dwarf::Attribute::Type);
  169. if (!type_die_offset.has_value())
  170. return {};
  171. VERIFY(type_die_offset.value().type() == Dwarf::AttributeValue::Type::DieReference);
  172. auto type_die = variable_die.compilation_unit().get_die_at_offset(type_die_offset.value().as_unsigned());
  173. auto type_name = type_die.get_attribute(Dwarf::Attribute::Name);
  174. if (type_name.has_value()) {
  175. variable_info.type_name = type_name.value().as_string();
  176. } else {
  177. dbgln("Unnamed DWARF type at offset: {}", type_die.offset());
  178. variable_info.type_name = "[Unnamed Type]";
  179. }
  180. return type_die;
  181. }
  182. static void parse_variable_location(Dwarf::DIE const& variable_die, DebugInfo::VariableInfo& variable_info, PtraceRegisters const& regs)
  183. {
  184. auto location_info = variable_die.get_attribute(Dwarf::Attribute::Location);
  185. if (!location_info.has_value()) {
  186. location_info = variable_die.get_attribute(Dwarf::Attribute::MemberLocation);
  187. }
  188. if (!location_info.has_value())
  189. return;
  190. switch (location_info.value().type()) {
  191. case Dwarf::AttributeValue::Type::UnsignedNumber:
  192. variable_info.location_type = DebugInfo::VariableInfo::LocationType::Address;
  193. variable_info.location_data.address = location_info.value().as_unsigned();
  194. break;
  195. case Dwarf::AttributeValue::Type::DwarfExpression: {
  196. auto expression_bytes = location_info.value().as_raw_bytes();
  197. auto value = Dwarf::Expression::evaluate(expression_bytes, regs);
  198. if (value.type != Dwarf::Expression::Type::None) {
  199. VERIFY(value.type == Dwarf::Expression::Type::UnsignedInteger);
  200. variable_info.location_type = DebugInfo::VariableInfo::LocationType::Address;
  201. variable_info.location_data.address = value.data.as_addr;
  202. }
  203. break;
  204. }
  205. default:
  206. dbgln("Warning: unhandled Dwarf location type: {}", to_underlying(location_info.value().type()));
  207. }
  208. }
  209. OwnPtr<DebugInfo::VariableInfo> DebugInfo::create_variable_info(Dwarf::DIE const& variable_die, PtraceRegisters const& regs, u32 address_offset) const
  210. {
  211. VERIFY(is_variable_tag_supported(variable_die.tag()));
  212. if (variable_die.tag() == Dwarf::EntryTag::FormalParameter
  213. && !variable_die.get_attribute(Dwarf::Attribute::Name).has_value()) {
  214. // We don't want to display info for unused parameters
  215. return {};
  216. }
  217. NonnullOwnPtr<VariableInfo> variable_info = make<VariableInfo>();
  218. auto name_attribute = variable_die.get_attribute(Dwarf::Attribute::Name);
  219. if (name_attribute.has_value())
  220. variable_info->name = name_attribute.value().as_string();
  221. auto type_die = parse_variable_type_die(variable_die, *variable_info);
  222. if (variable_die.tag() == Dwarf::EntryTag::Enumerator) {
  223. auto constant = variable_die.get_attribute(Dwarf::Attribute::ConstValue);
  224. VERIFY(constant.has_value());
  225. switch (constant.value().type()) {
  226. case Dwarf::AttributeValue::Type::UnsignedNumber:
  227. variable_info->constant_data.as_u32 = constant.value().as_unsigned();
  228. break;
  229. case Dwarf::AttributeValue::Type::SignedNumber:
  230. variable_info->constant_data.as_i32 = constant.value().as_signed();
  231. break;
  232. case Dwarf::AttributeValue::Type::String:
  233. variable_info->constant_data.as_string = constant.value().as_string();
  234. break;
  235. default:
  236. VERIFY_NOT_REACHED();
  237. }
  238. } else {
  239. parse_variable_location(variable_die, *variable_info, regs);
  240. variable_info->location_data.address += address_offset;
  241. }
  242. if (type_die.has_value())
  243. add_type_info_to_variable(type_die.value(), regs, variable_info);
  244. return variable_info;
  245. }
  246. void DebugInfo::add_type_info_to_variable(Dwarf::DIE const& type_die, PtraceRegisters const& regs, DebugInfo::VariableInfo* parent_variable) const
  247. {
  248. OwnPtr<VariableInfo> type_info;
  249. auto is_array_type = type_die.tag() == Dwarf::EntryTag::ArrayType;
  250. if (type_die.tag() == Dwarf::EntryTag::EnumerationType
  251. || type_die.tag() == Dwarf::EntryTag::StructureType
  252. || is_array_type) {
  253. type_info = create_variable_info(type_die, regs);
  254. }
  255. type_die.for_each_child([&](Dwarf::DIE const& member) {
  256. if (member.is_null())
  257. return;
  258. if (is_array_type && member.tag() == Dwarf::EntryTag::SubRangeType) {
  259. auto upper_bound = member.get_attribute(Dwarf::Attribute::UpperBound);
  260. VERIFY(upper_bound.has_value());
  261. auto size = upper_bound.value().as_unsigned() + 1;
  262. type_info->dimension_sizes.append(size);
  263. return;
  264. }
  265. if (!is_variable_tag_supported(member.tag()))
  266. return;
  267. auto member_variable = create_variable_info(member, regs, parent_variable->location_data.address);
  268. VERIFY(member_variable);
  269. if (type_die.tag() == Dwarf::EntryTag::EnumerationType) {
  270. member_variable->parent = type_info.ptr();
  271. type_info->members.append(member_variable.release_nonnull());
  272. } else {
  273. if (parent_variable->location_type != DebugInfo::VariableInfo::LocationType::Address)
  274. return;
  275. member_variable->parent = parent_variable;
  276. parent_variable->members.append(member_variable.release_nonnull());
  277. }
  278. });
  279. if (type_info) {
  280. if (is_array_type) {
  281. StringBuilder array_type_name;
  282. array_type_name.append(type_info->type_name);
  283. for (auto array_size : type_info->dimension_sizes) {
  284. array_type_name.append('[');
  285. array_type_name.append(String::formatted("{:d}", array_size));
  286. array_type_name.append(']');
  287. }
  288. parent_variable->type_name = array_type_name.to_string();
  289. }
  290. parent_variable->type = move(type_info);
  291. parent_variable->type->type_tag = type_die.tag();
  292. }
  293. }
  294. bool DebugInfo::is_variable_tag_supported(Dwarf::EntryTag const& tag)
  295. {
  296. return tag == Dwarf::EntryTag::Variable
  297. || tag == Dwarf::EntryTag::Member
  298. || tag == Dwarf::EntryTag::FormalParameter
  299. || tag == Dwarf::EntryTag::EnumerationType
  300. || tag == Dwarf::EntryTag::Enumerator
  301. || tag == Dwarf::EntryTag::StructureType
  302. || tag == Dwarf::EntryTag::ArrayType;
  303. }
  304. String DebugInfo::name_of_containing_function(FlatPtr address) const
  305. {
  306. auto function = get_containing_function(address);
  307. if (!function.has_value())
  308. return {};
  309. return function.value().name;
  310. }
  311. Optional<DebugInfo::VariablesScope> DebugInfo::get_containing_function(FlatPtr address) const
  312. {
  313. for (auto const& scope : m_scopes) {
  314. if (!scope.is_function || address < scope.address_low || address >= scope.address_high)
  315. continue;
  316. return scope;
  317. }
  318. return {};
  319. }
  320. Vector<DebugInfo::SourcePosition> DebugInfo::source_lines_in_scope(VariablesScope const& scope) const
  321. {
  322. Vector<DebugInfo::SourcePosition> source_lines;
  323. for (auto const& line : m_sorted_lines) {
  324. if (line.address < scope.address_low)
  325. continue;
  326. if (line.address >= scope.address_high)
  327. break;
  328. source_lines.append(SourcePosition::from_line_info(line));
  329. }
  330. return source_lines;
  331. }
  332. DebugInfo::SourcePosition DebugInfo::SourcePosition::from_line_info(Dwarf::LineProgram::LineInfo const& line)
  333. {
  334. return { line.file, line.line, line.address };
  335. }
  336. DebugInfo::SourcePositionWithInlines DebugInfo::get_source_position_with_inlines(FlatPtr address) const
  337. {
  338. // If the address is in an "inline chain", this is the inner-most inlined position.
  339. auto inner_source_position = get_source_position(address);
  340. auto die = m_dwarf_info.get_die_at_address(address);
  341. if (!die.has_value() || die->tag() == Dwarf::EntryTag::SubroutineType) {
  342. // Inline chain is empty
  343. return SourcePositionWithInlines { inner_source_position, {} };
  344. }
  345. Vector<SourcePosition> inline_chain;
  346. auto insert_to_chain = [&](Dwarf::DIE const& die) {
  347. auto caller_source_path = get_source_path_of_inline(die);
  348. auto caller_line = get_line_of_inline(die);
  349. if (!caller_source_path.has_value() || !caller_line.has_value()) {
  350. return;
  351. }
  352. inline_chain.append({ String::formatted("{}/{}", caller_source_path->directory, caller_source_path->filename), caller_line.value() });
  353. };
  354. while (die->tag() == Dwarf::EntryTag::InlinedSubroutine) {
  355. insert_to_chain(*die);
  356. if (!die->parent_offset().has_value()) {
  357. break;
  358. }
  359. auto parent = die->compilation_unit().dwarf_info().get_cached_die_at_offset(die->parent_offset().value());
  360. if (!parent.has_value()) {
  361. break;
  362. }
  363. die = *parent;
  364. }
  365. return SourcePositionWithInlines { inner_source_position, inline_chain };
  366. }
  367. Optional<Dwarf::LineProgram::DirectoryAndFile> DebugInfo::get_source_path_of_inline(Dwarf::DIE const& die) const
  368. {
  369. auto caller_file = die.get_attribute(Dwarf::Attribute::CallFile);
  370. if (caller_file.has_value()) {
  371. size_t file_index = 0;
  372. if (caller_file->type() == Dwarf::AttributeValue::Type::UnsignedNumber) {
  373. file_index = caller_file->as_unsigned();
  374. } else if (caller_file->type() == Dwarf::AttributeValue::Type::SignedNumber) {
  375. // For some reason, the file_index is sometimes stored as a signed number.
  376. auto signed_file_index = caller_file->as_signed();
  377. VERIFY(signed_file_index >= 0);
  378. VERIFY(static_cast<u64>(signed_file_index) <= NumericLimits<size_t>::max());
  379. file_index = static_cast<size_t>(caller_file->as_signed());
  380. } else {
  381. return {};
  382. }
  383. return die.compilation_unit().line_program().get_directory_and_file(file_index);
  384. }
  385. return {};
  386. }
  387. Optional<uint32_t> DebugInfo::get_line_of_inline(Dwarf::DIE const& die) const
  388. {
  389. auto caller_line = die.get_attribute(Dwarf::Attribute::CallLine);
  390. if (!caller_line.has_value())
  391. return {};
  392. if (caller_line->type() != Dwarf::AttributeValue::Type::UnsignedNumber)
  393. return {};
  394. return caller_line.value().as_unsigned();
  395. }
  396. }