// 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 "Expressions.h" #include "ApiContext.h" #include "WasmModule.h" #include "WasmVendorPlugins.h" #include "lldb-eval/ast.h" #include "lldb-eval/context.h" #include "lldb-eval/eval.h" #include "lldb-eval/parser.h" #include "lldb-eval/parser_context.h" #include "lldb-eval/value.h" #include "lldb/Core/Module.h" #include "lldb/Core/Section.h" #include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/SymbolContext.h" #include "lldb/Symbol/Type.h" #include "lldb/Symbol/TypeSystem.h" #include "lldb/Target/Process.h" #include "lldb/Utility/ArchSpec.h" #include "lldb/Utility/Listener.h" #include "llvm/ADT/StringRef.h" #include #include #include #include #include namespace symbols_backend { static lldb_private::CompilerType GetTopType(lldb_private::CompilerType t) { if (!t.IsValid() || !t.IsTypedefType()) { return t; } return GetTopType(t.GetTypedefedType()); } struct WasmValueLoaderContext : SymbolFileWasmDWARF::WasmValueLoader { const api::DebuggerProxy& proxy; explicit WasmValueLoaderContext(const api::DebuggerProxy& proxy, SymbolFileWasmDWARF& symbol_file) : SymbolFileWasmDWARF::WasmValueLoader(symbol_file), proxy(proxy) {} llvm::Expected LoadWASMValue( uint8_t storage_type, const lldb_private::DataExtractor& data, lldb::offset_t& offset) final { uint64_t index = 0; switch (storage_type) { case 0x00: // local case 0x01: // global case 0x02: // operand index = data.GetULEB128(&offset); break; case 0x03: // global i32 index = data.GetU32(&offset); break; default: return llvm::createStringError(llvm::inconvertibleErrorCode(), "Invalid WASM value storage type"); } switch (storage_type) { case 0x00: // local return proxy.GetLocal(index); case 0x02: // operand return proxy.GetOperand(index); case 0x01: // global case 0x03: // global i32 return proxy.GetGlobal(index); } return llvm::createStringError(llvm::inconvertibleErrorCode(), "Invalid WASM value storage type"); } }; lldb_private::CompilerType GetCompilerType(lldb::SBType t) { struct Derived : lldb::SBType { explicit Derived(const lldb::SBType& t) : SBType(t) {} auto Get() { return ref().GetCompilerType(false); } }; return Derived{t}.Get(); } llvm::Optional CheckError(lldb::SBValue value) { auto e = value.GetError(); if (!e.IsValid() || e.Success()) { return {}; } auto message = e.GetCString(); return llvm::createStringError(llvm::inconvertibleErrorCode(), message); } llvm::Expected InterpretExpression( const WasmModule& module, lldb_private::TypeSystem& type_system, lldb_private::SymbolContext& sc, size_t frame_offset, size_t inline_frame_index, lldb_private::Address addr, llvm::StringRef expression, const api::DebuggerProxy& proxy) { auto target = module.Target()->shared_from_this(); lldb::ListenerSP listener = lldb_private::Listener::MakeListener("wasm32"); lldb::ProcessSP process = target->CreateProcess(listener, "wasm32", nullptr, false); if (!process) { return llvm::createStringError(llvm::inconvertibleErrorCode(), "Failed to create process"); } lldb::SectionSP code_section = module.Module()->GetObjectFile()->GetSectionList()->FindSectionByType( lldb::eSectionTypeCode, false); target->SetSectionLoadAddress(code_section, 0); static_cast(process.get()) ->SetProxyAndFrameOffset(proxy, frame_offset); process->UpdateThreadListIfNeeded(); process->GetThreadList().SetSelectedThreadByID(0); auto thread = std::static_pointer_cast( process->GetThreadList().GetSelectedThread()); WasmValueLoaderContext loader(proxy, *llvm::cast( module.Module()->GetSymbolFile())); auto sm = lldb_eval::SourceManager::Create(expression.str()); auto ctx = lldb_eval::Context::Create(sm, lldb::SBFrame{thread->GetFrame()}); lldb_eval::Parser parser(ctx); lldb_eval::Error e; auto tree = parser.Run(e); if (e || !tree || tree->is_error()) { return llvm::createStringError(llvm::inconvertibleErrorCode(), e.message().c_str()); } lldb_eval::Interpreter interpreter(target, sm); auto result = interpreter.Eval(tree.get(), e); if (!result.IsValid() || e) { return llvm::createStringError(llvm::inconvertibleErrorCode(), e.message().c_str()); } if (auto e = CheckError(result.inner_value())) { return std::move(*e); } auto type = GetCompilerType(ToSBType(result.type())); auto top_type = GetTopType(type); auto val = result.inner_value(); llvm::Optional address; if (auto address_of = val.AddressOf()) { address = address_of.GetValueAsUnsigned(); } switch (top_type.GetBasicTypeEnumeration()) { case lldb::BasicType::eBasicTypeChar: case lldb::BasicType::eBasicTypeSignedChar: case lldb::BasicType::eBasicTypeChar8: case lldb::BasicType::eBasicTypeChar16: case lldb::BasicType::eBasicTypeChar32: case lldb::BasicType::eBasicTypeShort: case lldb::BasicType::eBasicTypeInt: case lldb::BasicType::eBasicTypeLong: case lldb::BasicType::eBasicTypeWChar: case lldb::BasicType::eBasicTypeSignedWChar: case lldb::BasicType::eBasicTypeLongLong: { auto integer = result.GetValueAsSigned(); if (auto integer_size = type.GetByteSize(nullptr)) { switch (*integer_size) { case 1: return ExpressionResult{type, static_cast(integer), address}; case 2: return ExpressionResult{type, static_cast(integer), address}; case 4: return ExpressionResult{type, static_cast(integer), address}; case 8: return ExpressionResult{type, static_cast(integer), address}; } break; } } case lldb::BasicType::eBasicTypeUnsignedChar: case lldb::BasicType::eBasicTypeUnsignedShort: case lldb::BasicType::eBasicTypeUnsignedWChar: case lldb::BasicType::eBasicTypeUnsignedInt: case lldb::BasicType::eBasicTypeUnsignedLong: case lldb::BasicType::eBasicTypeUnsignedLongLong: { auto integer = result.GetUInt64(); if (auto integer_size = type.GetByteSize(nullptr)) { switch (*integer_size) { case 1: return ExpressionResult{type, static_cast(integer), address}; case 2: return ExpressionResult{type, static_cast(integer), address}; case 4: return ExpressionResult{type, static_cast(integer), address}; case 8: return ExpressionResult{type, static_cast(integer), address}; } } break; } case lldb::BasicType::eBasicTypeBool: return ExpressionResult{type, result.GetBool(), address}; case lldb::BasicType::eBasicTypeFloat: return ExpressionResult{type, result.GetFloat().convertToFloat(), address}; case lldb::BasicType::eBasicTypeDouble: return ExpressionResult{type, result.GetFloat().convertToDouble(), address}; case lldb::BasicType::eBasicTypeVoid: return ExpressionResult{type, std::monostate{}, address}; case lldb::BasicType::eBasicTypeNullPtr: return ExpressionResult{type, nullptr, address}; case lldb::BasicType::eBasicTypeHalf: case lldb::BasicType::eBasicTypeLongDouble: case lldb::BasicType::eBasicTypeFloatComplex: case lldb::BasicType::eBasicTypeDoubleComplex: case lldb::BasicType::eBasicTypeLongDoubleComplex: case lldb::BasicType::eBasicTypeObjCID: case lldb::BasicType::eBasicTypeObjCClass: case lldb::BasicType::eBasicTypeObjCSel: case lldb::BasicType::eBasicTypeInt128: case lldb::BasicType::eBasicTypeUnsignedInt128: case lldb::BasicType::eBasicTypeOther: return llvm::createStringError(llvm::inconvertibleErrorCode(), "Invalid basic type %s", result.type()->GetName().str().c_str()); case lldb::BasicType::eBasicTypeInvalid: break; } bool is_signed = false; if (top_type.IsEnumerationType(is_signed)) { if (is_signed) { auto integer = result.GetValueAsSigned(); if (auto integer_size = type.GetByteSize(nullptr)) { switch (*integer_size) { case 1: return ExpressionResult{type, static_cast(integer), address}; case 2: return ExpressionResult{type, static_cast(integer), address}; case 4: return ExpressionResult{type, static_cast(integer), address}; case 8: return ExpressionResult{type, static_cast(integer), address}; } } } auto integer = result.GetUInt64(); if (auto integer_size = type.GetByteSize(nullptr)) { switch (*integer_size) { case 1: return ExpressionResult{type, static_cast(integer), address}; case 2: return ExpressionResult{type, static_cast(integer), address}; case 4: return ExpressionResult{type, static_cast(integer), address}; case 8: return ExpressionResult{type, static_cast(integer), address}; } } } if (result.IsPointer()) { if (module.Module()->GetArchitecture().GetAddressByteSize() == 4) { return ExpressionResult{type, static_cast(result.GetUInt64()), address}; } else { return ExpressionResult{type, static_cast(result.GetUInt64()), address}; } } auto ptr = result.AddressOf(); if (ptr.IsValid()) { return ExpressionResult{type, reinterpret_cast(ptr.GetUInt64()), address}; } return llvm::createStringError(llvm::inconvertibleErrorCode(), "Cannot evaluate in-memory value with type %s", result.type()->GetName().str().c_str()); } } // namespace symbols_backend