// Copyright 2023 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "ApiContext.h" #include "Expressions.h" #include "Variables.h" #include "WasmModule.h" #include "api.h" #include "lldb/Symbol/CompilerType.h" #include "lldb/Utility/ConstString.h" #include "lldb/lldb-enumerations.h" #include "lldb/lldb-types.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/None.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Twine.h" #include "llvm/BinaryFormat/Wasm.h" #include "llvm/Support/Debug.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/raw_ostream.h" #include #include #include #include #include #include #include #include #include #define DEBUG_TYPE "symbols-backend" namespace symbols_backend { namespace api { namespace { Error MakeError(Error::Code ec, llvm::Twine message) { Error e; e.SetCode(ec); e.SetMessage(message.str()); return e; } Error MakeError(Error::Code ec, llvm::Error error) { Error e; e.SetCode(ec); llvm::handleAllErrors(std::move(error), [&e](const llvm::StringError& string_error) { e.SetMessage(string_error.getMessage()); }); return e; } Error MakeNotFoundError(llvm::StringRef raw_module_id) { return MakeError(Error::Code::kModuleNotFoundError, "Module with id '" + raw_module_id + "' not found"); } Error MakeEvalError(llvm::Error error) { Error e; e.SetCode(Error::Code::kEvalError); llvm::handleAllErrors(std::move(error), [&e](const llvm::StringError& string_error) { e.SetMessage(string_error.getMessage() + " (Not all C++ expressions supported)"); }); return e; } Variable::Scope ToApiScope(lldb::ValueType scope) { switch (scope) { case lldb::eValueTypeVariableGlobal: case lldb::eValueTypeVariableStatic: return Variable::Scope::kGlobal; case lldb::eValueTypeVariableArgument: return Variable::Scope::kParameter; case lldb::eValueTypeVariableLocal: return Variable::Scope::kLocal; default: llvm::errs() << "Got variable scope " << scope << "\n"; llvm_unreachable("Unhandled variable scope"); } } llvm::SmallVector ToRawLocationRanges( llvm::SmallSet, 1>&& ranges, std::string raw_module_id) { llvm::SmallVector locations; for (auto offset_pair : ranges) { RawLocationRange& location = locations.emplace_back(); location.SetRawModuleId(raw_module_id); location.SetStartOffset(offset_pair.first); location.SetEndOffset(offset_pair.first + offset_pair.second); } return locations; } } // namespace // Notify the plugin about a new script AddRawModuleResponse ApiContext::AddRawModule( std::string raw_module_id, // A raw module identifier std::string path // The path to the file with the wasm bytes ) { AddRawModuleResponse response; if (FindModule(raw_module_id)) { response.SetError( MakeError(Error::Code::kInternalError, "Duplicate module with id '" + raw_module_id + "'")); } else if (auto m = AddModule(raw_module_id, path)) { auto source_info = m->GetSourceScripts(); response.SetSources( {source_info.sources.begin(), source_info.sources.end()}); response.SetDwos({source_info.dwos.begin(), source_info.dwos.end()}); } else { response.SetError(MakeError(Error::Code::kInternalError, "Unable to load file '" + path + "'")); } return response; }; void ApiContext::RemoveRawModule( std::string raw_module_id // A raw module identifier ) { DeleteModule(raw_module_id); } // Find locations in raw modules from a location in a source file SourceLocationToRawLocationResponse ApiContext::SourceLocationToRawLocation( std::string raw_module_id, std::string source_file, int32_t line_number, int32_t column_number) { SourceLocationToRawLocationResponse response; auto module = FindModule(raw_module_id); if (!module) { response.SetError(MakeNotFoundError(raw_module_id)); return response; } llvm::SmallVector locations = ToRawLocationRanges( module->GetOffsetFromSourceLocation( {source_file, static_cast(line_number + 1), static_cast(column_number + 1)}), raw_module_id); response.SetRawLocationRanges({locations.begin(), locations.end()}); return response; }; // Find locations in source files from a location in a raw module RawLocationToSourceLocationResponse ApiContext::RawLocationToSourceLocation( std::string raw_module_id, int32_t code_offset, int32_t inline_frame_index) { RawLocationToSourceLocationResponse response; auto module = FindModule(raw_module_id); if (!module) { response.SetError(MakeNotFoundError(raw_module_id)); return response; } llvm::SmallVector locations; for (auto& source_loc : module->GetSourceLocationFromOffset(code_offset, inline_frame_index)) { SourceLocation& location = locations.emplace_back(); location.SetSourceFile(source_loc.file); location.SetRawModuleId(raw_module_id); location.SetLineNumber(source_loc.line - 1); location.SetColumnNumber(source_loc.column - 1); } response.SetSourceLocation({locations.begin(), locations.end()}); return response; } // List all variables in lexical scope at a location in a raw module ListVariablesInScopeResponse ApiContext::ListVariablesInScope( std::string raw_module_id, int32_t code_offset, int32_t inline_frame_index) { ListVariablesInScopeResponse response; auto module = FindModule(raw_module_id); if (!module) { response.SetError(MakeNotFoundError(raw_module_id)); return response; } llvm::SmallVector variables; for (auto& var : module->GetVariablesInScope(code_offset, inline_frame_index)) { if (var.name.empty()) { // Skip anonymous objects, since we can't get their value through // `evaluate`. continue; } Variable& variable = variables.emplace_back(); variable.SetScope(ToApiScope(var.scope)); variable.SetName(var.name); variable.SetType(var.type); } response.SetVariable({variables.begin(), variables.end()}); return response; } GetFunctionInfoResponse ApiContext::GetFunctionInfo(std::string raw_module_id, int32_t code_offset) { GetFunctionInfoResponse response; auto module = FindModule(raw_module_id); if (!module) { response.SetError(MakeNotFoundError(raw_module_id)); return response; } FunctionInfo fi = module->GetFunctionInfo(code_offset); response.SetFunctionNames({fi.names.begin(), fi.names.end()}); response.SetMissingSymbolFiles( {fi.missing_symbols.begin(), fi.missing_symbols.end()}); return response; } namespace { std::vector GetTypeNames(lldb_private::CompilerType type) { std::vector names; lldb_private::CompilerType original_type = type; while (type.IsValid()) { if (const char* type_name = type.GetDisplayTypeName().GetCString()) { names.emplace_back(type_name); } if (const char* type_name = type.GetTypeName().GetCString()) { if (names.back() != type_name) { names.emplace_back(type_name); } } type = type.GetTypedefedType(); } // If the original input type is a fixed-size integer or enum type, append a // matching c++ fixed-width integer type name to the list to simplify integer // handling. bool is_signed = false; if (original_type.IsIntegerOrEnumerationType(is_signed)) { if (original_type.IsEnumerationType(is_signed)) { original_type = original_type.GetEnumerationIntegerType(); } if (auto byte_size = original_type.GetByteSize(nullptr)) { switch (*byte_size) { case 8: names.push_back(is_signed ? "int64_t" : "uint64_t"); break; case 4: names.push_back(is_signed ? "int32_t" : "uint32_t"); break; case 2: names.push_back(is_signed ? "int16_t" : "uint16_t"); break; case 1: names.push_back(is_signed ? "int8_t" : "uint8_t"); break; } } } return names; } } // namespace GetInlinedFunctionRangesResponse ApiContext::GetInlinedFunctionRanges( std::string raw_module_id, int32_t code_offset) { GetInlinedFunctionRangesResponse response; auto module = FindModule(raw_module_id); if (!module) { response.SetError(MakeNotFoundError(raw_module_id)); return response; } llvm::SmallVector locations = ToRawLocationRanges( module->GetInlineFunctionAddressRanges(code_offset), raw_module_id); response.SetRawLocationRanges({locations.begin(), locations.end()}); return response; } GetInlinedCalleesRangesResponse ApiContext::GetInlinedCalleesRanges( std::string raw_module_id, int32_t code_offset) { GetInlinedCalleesRangesResponse response; auto module = FindModule(raw_module_id); if (!module) { response.SetError(MakeNotFoundError(raw_module_id)); return response; } llvm::SmallVector locations = ToRawLocationRanges( module->GetChildInlineFunctionAddressRanges(code_offset), raw_module_id); response.SetRawLocationRanges({locations.begin(), locations.end()}); return response; } GetMappedLinesResponse ApiContext::GetMappedLines(std::string raw_module_id, std::string source_file_url) { GetMappedLinesResponse response; auto module = FindModule(raw_module_id); if (!module) { response.SetError(MakeNotFoundError(raw_module_id)); return response; } std::vector lines = module->GetMappedLines(source_file_url); for (int32_t& line : lines) { --line; } response.SetMappedLines(std::move(lines)); return response; } std::shared_ptr ApiContext::AddModule(llvm::StringRef id, llvm::StringRef path) { if (!llvm::sys::fs::exists(path)) { LLVM_DEBUG(llvm::dbgs() << "Module '" << id << "' at " << path << " not found\n"); return nullptr; } auto maybe_module = WasmModule::CreateFromFile(path); if (!maybe_module) { llvm::errs() << llvm::toString(maybe_module.takeError()); return nullptr; } const auto& module = modules_.insert({id, std::move(*maybe_module)}).first->second; if (module) { LLVM_DEBUG(llvm::dbgs() << "Loaded module " << id << " with " << module->GetSourceScripts().sources.size() << " source files\n"); } return module; } std::shared_ptr ApiContext::FindModule(llvm::StringRef id) const { auto it = modules_.find(id); if (it == modules_.end()) { return nullptr; } return it->second; } void ApiContext::DeleteModule(llvm::StringRef id) { modules_.erase(id); } api::TypeInfo ApiContext::GetApiTypeInfo( lldb_private::CompilerType type, const llvm::SmallVectorImpl& member_info) { std::vector enumerators; type.ForEachEnumerator([&](const lldb_private::CompilerType& type, lldb_private::ConstString label, const llvm::APSInt& value) { enumerators.push_back(api::Enumerator() .SetName(label.AsCString("")) .SetValue(value.getExtValue()) .SetTypeId(GetTypeId(type))); return true; }); auto size = type.GetByteSize(nullptr); uint64_t array_size = 0; size_t alignment = type.GetTypeBitAlign(nullptr).value_or(0) / 8; bool has_elements = type.IsPointerOrReferenceType() || type.IsArrayType(nullptr, &array_size, nullptr) || type.IsVectorType(nullptr, &array_size); bool can_expand = type.IsAggregateType() || has_elements; bool is_signed = false; bool has_value = type.IsScalarType() || type.IsEnumerationType(is_signed) || has_elements; std::vector members; for (const auto& member : member_info) { members.push_back(FieldInfo() .SetName(member.MemberName().str()) .SetOffset(member.OffsetInParent()) .SetTypeId(GetTypeId(member.Type()))); } return api::TypeInfo() .SetCanExpand(can_expand) .SetArraySize(array_size) .SetHasValue(has_value) .SetTypeId(GetTypeId(type)) .SetTypeNames(GetTypeNames(type)) .SetSize(size ? *size : 0) .SetIsPointer(type.IsPointerOrReferenceType(nullptr)) .SetAlignment(alignment) .SetMembers(std::move(members)) .SetEnumerators(std::move(enumerators)); } llvm::Expected> ApiContext::GetApiTypeInfos( lldb_private::CompilerType type, int32_t required_type_depth) { std::deque> queue{{type, 0}}; std::vector type_infos; llvm::DenseSet visited_types; while (!queue.empty()) { lldb_private::CompilerType type; int32_t depth; std::tie(type, depth) = queue.front(); queue.pop_front(); if (required_type_depth > 0 && depth > required_type_depth) { continue; } if (!visited_types.insert(type.GetOpaqueQualType()).second) { continue; } auto member_info = SubObjectInfo::GetMembers(type); for (const auto& member : member_info) { if (!visited_types.contains(member.Type().GetOpaqueQualType())) { queue.push_back({member.Type(), depth + 1}); } } type_infos.push_back(GetApiTypeInfo(type, member_info)); } return type_infos; } std::string ApiContext::GetTypeId(lldb_private::CompilerType type) { std::string key = std::to_string(reinterpret_cast(type.GetOpaqueQualType())); types_[key] = type; return key; } llvm::Optional ApiContext::GetTypeFromId( llvm::StringRef type_id) { auto it = types_.find(type_id.str()); if (it == types_.end()) { return llvm::None; } return it->getValue(); } struct EvalVisitor { ApiContext& context; lldb_private::CompilerType type; llvm::Optional address; EvalVisitor(ApiContext& context, lldb_private::CompilerType type, llvm::Optional address) : context(context), type(type), address(address) {} api::EvaluateExpressionResponse MakeResponse() { auto member_type_infos = context.GetApiTypeInfos(type, 0); if (!member_type_infos) { return api::EvaluateExpressionResponse().SetError( MakeEvalError(member_type_infos.takeError())); } api::TypeInfo root_type = member_type_infos->front(); return api::EvaluateExpressionResponse() .SetTypeInfos(std::move(*member_type_infos)) .SetRoot(root_type) .SetMemoryAddress(address ? llvm::Optional(*address) : llvm::None); } // Most types are stringified in the JS wrapper, including most primitive // types as implemented below. There's two exceptions that we're handling // here because they're impossible/hard to do in JS, which is enum labels and // floating point values. Stringifying floats and doubles in JS is subtly // different than in C++ (or rather lldb), in particular for floats which // have different level of precision than JS's number. template api::EvaluateExpressionResponse MakeResponse(T v) { auto begin = reinterpret_cast(&v); auto end = begin + sizeof(T); std::vector data = {begin, end}; bool is_signed = false; llvm::Optional enum_label; if (type.IsEnumerationType(is_signed)) { type.ForEachEnumerator([&enum_label, v](auto t, auto label, auto value) { if (value == v) { enum_label = std::string(label.GetStringRef()); return false; } return true; }); } return MakeResponse().SetData(data).SetDisplayValue(std::move(enum_label)); } auto operator()(std::monostate v) { return MakeResponse(); } auto operator()(bool v) { return MakeResponse(v); } auto operator()(int8_t v) { return MakeResponse(v); } auto operator()(uint8_t v) { return MakeResponse(v); } auto operator()(int16_t v) { return MakeResponse(v); } auto operator()(uint16_t v) { return MakeResponse(v); } auto operator()(int32_t v) { return MakeResponse(v); } auto operator()(uint32_t v) { return MakeResponse(v); } auto operator()(int64_t v) { return MakeResponse(v); } auto operator()(uint64_t v) { return MakeResponse(v); } auto operator()(float v) { llvm::APFloat f(v); llvm::SmallVector str; f.toString(str, 0, 6); return MakeResponse(v).SetDisplayValue(std::string(str.data(), str.size())); } auto operator()(double v) { llvm::APFloat f(v); llvm::SmallVector str; f.toString(str, 0, 6); return MakeResponse(v).SetDisplayValue(std::string(str.data(), str.size())); } auto operator()(void* v) { return MakeResponse().SetLocation(reinterpret_cast(v)); } auto operator()(std::nullptr_t v) { return MakeResponse(0); } }; llvm::Expected DebuggerProxy::ReadMemory(lldb::addr_t address, void* buffer, size_t size) const { return proxy_.call("readMemory", static_cast(address), reinterpret_cast(buffer), size); } static llvm::Expected readWasmValue( const emscripten::val& value) { std::string type = value["type"].as(); if (type == "i32") { return DebuggerProxy::WasmValue{llvm::wasm::ValType::I32, value["value"].as()}; } if (type == "i64") { return DebuggerProxy::WasmValue{llvm::wasm::ValType::I64, value["value"].as()}; } if (type == "f32") { return DebuggerProxy::WasmValue{llvm::wasm::ValType::F32, value["value"].as()}; } if (type == "f64") { return DebuggerProxy::WasmValue{llvm::wasm::ValType::F64, value["value"].as()}; } if (type == "reftype") { // Only a scalar value can cross the DWARF interpreter, so we // encode the value into a 64-bit integer. int64_t encodedValue = value["index"].as(); std::string valueClass = value["valueClass"].as(); if (valueClass == "local") { encodedValue |= (int64_t)1 << 32; } else if (valueClass == "operand") { encodedValue |= (int64_t)2 << 32; } else if (valueClass != "global") { llvm::errs() << "Got value class " << encodedValue << "\n"; llvm_unreachable("Unhandled value class"); } return DebuggerProxy::WasmValue{llvm::wasm::ValType::I64, encodedValue}; } return llvm::createStringError(llvm::inconvertibleErrorCode(), "Invalid value type %s", type.c_str()); } llvm::Expected DebuggerProxy::GetGlobal( size_t index) const { return readWasmValue(proxy_.call("getGlobal", index)); } llvm::Expected DebuggerProxy::GetLocal( size_t index) const { return readWasmValue(proxy_.call("getLocal", index)); } llvm::Expected DebuggerProxy::GetOperand( size_t index) const { return readWasmValue(proxy_.call("getOperand", index)); } api::EvaluateExpressionResponse ApiContext::EvaluateExpression( RawLocation location, std::string expression, emscripten::val debug_proxy) { std::string raw_module_id = location.GetRawModuleId(); auto module = FindModule(raw_module_id); if (!module) { return api::EvaluateExpressionResponse().SetError( MakeNotFoundError(raw_module_id)); } auto result = module->InterpretExpression( location.GetCodeOffset(), location.GetInlineFrameIndex(), expression, DebuggerProxy{debug_proxy}); if (!result) { return api::EvaluateExpressionResponse().SetError( MakeError(Error::Code::kEvalError, result.takeError())); } return std::visit(EvalVisitor(*this, result->type, result->address), result->value); } } // namespace api } // namespace symbols_backend #ifndef NDEBUG namespace { struct Logging { Logging() { lldb_private::Log::Initialize(); lldb_private::Log::ListAllLogChannels(llvm::errs()); auto stream = std::make_shared(2, false, true); lldb_private::Log::EnableLogChannel(stream, 0, "lldb", {"default"}, llvm::errs()); } }; static Logging l; } // namespace #endif