extensions/cxx_debugging/lib/ApiContext.cc - devtools/devtools-frontend - Git at Google

 // 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 <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <deque>
 #include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

 #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<RawLocationRange, 1> ToRawLocationRanges(
     llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>&& ranges,
     std::string raw_module_id) {
   llvm::SmallVector<RawLocationRange, 1> 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<RawLocationRange, 1> locations = ToRawLocationRanges(
       module->GetOffsetFromSourceLocation(
           {source_file, static_cast<uint32_t>(line_number + 1),
            static_cast<uint16_t>(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<SourceLocation, 1> 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<Variable, 1> 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<std::string> GetTypeNames(lldb_private::CompilerType type) {
   std::vector<std::string> 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<RawLocationRange, 1> 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<RawLocationRange, 1> 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<int32_t> lines = module->GetMappedLines(source_file_url);
   for (int32_t& line : lines) {
     --line;
   }
   response.SetMappedLines(std::move(lines));
   return response;
 }

 std::shared_ptr<WasmModule> 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<WasmModule> 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<SubObjectInfo>& member_info) {
   std::vector<api::Enumerator> 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<api::FieldInfo> 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<std::vector<api::TypeInfo>> ApiContext::GetApiTypeInfos(
     lldb_private::CompilerType type,
     int32_t required_type_depth) {
   std::deque<std::pair<lldb_private::CompilerType, int32_t>> queue{{type, 0}};
   std::vector<api::TypeInfo> type_infos;
   llvm::DenseSet<lldb::opaque_compiler_type_t> 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<uintptr_t>(type.GetOpaqueQualType()));
   types_[key] = type;
   return key;
 }

 llvm::Optional<lldb_private::CompilerType> 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<size_t> address;

   EvalVisitor(ApiContext& context,
               lldb_private::CompilerType type,
               llvm::Optional<size_t> 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<int32_t>(*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 <typename T>
   api::EvaluateExpressionResponse MakeResponse(T v) {
     auto begin = reinterpret_cast<unsigned char*>(&v);
     auto end = begin + sizeof(T);
     std::vector<int32_t> data = {begin, end};

     bool is_signed = false;
     llvm::Optional<std::string> 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<char, 256> 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<char, 256> 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<uint64_t>(v));
   }
   auto operator()(std::nullptr_t v) { return MakeResponse<intptr_t>(0); }
 };

 llvm::Expected<size_t> DebuggerProxy::ReadMemory(lldb::addr_t address,
                                                  void* buffer,
                                                  size_t size) const {
   return proxy_.call<size_t>("readMemory", static_cast<size_t>(address),
                              reinterpret_cast<size_t>(buffer), size);
 }

 static llvm::Expected<DebuggerProxy::WasmValue> readWasmValue(
     const emscripten::val& value) {
   std::string type = value["type"].as<std::string>();
   if (type == "i32") {
     return DebuggerProxy::WasmValue{llvm::wasm::ValType::I32,
                                     value["value"].as<int32_t>()};
   }
   if (type == "i64") {
     return DebuggerProxy::WasmValue{llvm::wasm::ValType::I64,
                                     value["value"].as<int64_t>()};
   }
   if (type == "f32") {
     return DebuggerProxy::WasmValue{llvm::wasm::ValType::F32,
                                     value["value"].as<float>()};
   }
   if (type == "f64") {
     return DebuggerProxy::WasmValue{llvm::wasm::ValType::F64,
                                     value["value"].as<double>()};
   }
   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<uint32_t>();
     std::string valueClass = value["valueClass"].as<std::string>();
     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::WasmValue> DebuggerProxy::GetGlobal(
     size_t index) const {
   return readWasmValue(proxy_.call<emscripten::val>("getGlobal", index));
 }
 llvm::Expected<DebuggerProxy::WasmValue> DebuggerProxy::GetLocal(
     size_t index) const {
   return readWasmValue(proxy_.call<emscripten::val>("getLocal", index));
 }
 llvm::Expected<DebuggerProxy::WasmValue> DebuggerProxy::GetOperand(
     size_t index) const {
   return readWasmValue(proxy_.call<emscripten::val>("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<llvm::raw_fd_ostream>(2, false, true);
     lldb_private::Log::EnableLogChannel(stream, 0, "lldb", {"default"},
                                         llvm::errs());
   }
 };

 static Logging l;
 }  // namespace
 #endif
	// 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 <algorithm>
	#include <cstddef>
	#include <cstdint>
	#include <deque>
	#include <functional>
	#include <memory>
	#include <string>
	#include <utility>
	#include <vector>

	#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<RawLocationRange, 1> ToRawLocationRanges(
	llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>&& ranges,
	std::string raw_module_id) {
	llvm::SmallVector<RawLocationRange, 1> 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<RawLocationRange, 1> locations = ToRawLocationRanges(
	module->GetOffsetFromSourceLocation(
	{source_file, static_cast<uint32_t>(line_number + 1),
	static_cast<uint16_t>(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<SourceLocation, 1> 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<Variable, 1> 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<std::string> GetTypeNames(lldb_private::CompilerType type) {
	std::vector<std::string> 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<RawLocationRange, 1> 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<RawLocationRange, 1> 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<int32_t> lines = module->GetMappedLines(source_file_url);
	for (int32_t& line : lines) {
	--line;
	}
	response.SetMappedLines(std::move(lines));
	return response;
	}

	std::shared_ptr<WasmModule> 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<WasmModule> 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<SubObjectInfo>& member_info) {
	std::vector<api::Enumerator> 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<api::FieldInfo> 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<std::vector<api::TypeInfo>> ApiContext::GetApiTypeInfos(
	lldb_private::CompilerType type,
	int32_t required_type_depth) {
	std::deque<std::pair<lldb_private::CompilerType, int32_t>> queue{{type, 0}};
	std::vector<api::TypeInfo> type_infos;
	llvm::DenseSet<lldb::opaque_compiler_type_t> 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<uintptr_t>(type.GetOpaqueQualType()));
	types_[key] = type;
	return key;
	}

	llvm::Optional<lldb_private::CompilerType> 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<size_t> address;

	EvalVisitor(ApiContext& context,
	lldb_private::CompilerType type,
	llvm::Optional<size_t> 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<int32_t>(*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 <typename T>
	api::EvaluateExpressionResponse MakeResponse(T v) {
	auto begin = reinterpret_cast<unsigned char*>(&v);
	auto end = begin + sizeof(T);
	std::vector<int32_t> data = {begin, end};

	bool is_signed = false;
	llvm::Optional<std::string> 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<char, 256> 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<char, 256> 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<uint64_t>(v));
	}
	auto operator()(std::nullptr_t v) { return MakeResponse<intptr_t>(0); }
	};

	llvm::Expected<size_t> DebuggerProxy::ReadMemory(lldb::addr_t address,
	void* buffer,
	size_t size) const {
	return proxy_.call<size_t>("readMemory", static_cast<size_t>(address),
	reinterpret_cast<size_t>(buffer), size);
	}

	static llvm::Expected<DebuggerProxy::WasmValue> readWasmValue(
	const emscripten::val& value) {
	std::string type = value["type"].as<std::string>();
	if (type == "i32") {
	return DebuggerProxy::WasmValue{llvm::wasm::ValType::I32,
	value["value"].as<int32_t>()};
	}
	if (type == "i64") {
	return DebuggerProxy::WasmValue{llvm::wasm::ValType::I64,
	value["value"].as<int64_t>()};
	}
	if (type == "f32") {
	return DebuggerProxy::WasmValue{llvm::wasm::ValType::F32,
	value["value"].as<float>()};
	}
	if (type == "f64") {
	return DebuggerProxy::WasmValue{llvm::wasm::ValType::F64,
	value["value"].as<double>()};
	}
	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<uint32_t>();
	std::string valueClass = value["valueClass"].as<std::string>();
	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::WasmValue> DebuggerProxy::GetGlobal(
	size_t index) const {
	return readWasmValue(proxy_.call<emscripten::val>("getGlobal", index));
	}
	llvm::Expected<DebuggerProxy::WasmValue> DebuggerProxy::GetLocal(
	size_t index) const {
	return readWasmValue(proxy_.call<emscripten::val>("getLocal", index));
	}
	llvm::Expected<DebuggerProxy::WasmValue> DebuggerProxy::GetOperand(
	size_t index) const {
	return readWasmValue(proxy_.call<emscripten::val>("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<llvm::raw_fd_ostream>(2, false, true);
	lldb_private::Log::EnableLogChannel(stream, 0, "lldb", {"default"},
	llvm::errs());
	}
	};

	static Logging l;
	} // namespace
	#endif