chrome-devtools-frontend 1.0.1473514 → 1.0.1510180

package/extensions/cxx_debugging/lib/WasmModule.cc

@@ -1,573 +0,0 @@
-// Copyright 2023 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "WasmModule.h"
-#include "Expressions.h"
-#include "WasmVendorPlugins.h"
-
-#include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
-#include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
-#include "lldb/Core/Address.h"
-#include "lldb/Core/AddressRange.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Core/FileSpecList.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/Section.h"
-#include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/CompileUnit.h"
-#include "lldb/Symbol/CompilerType.h"
-#include "lldb/Symbol/Function.h"
-#include "lldb/Symbol/LineEntry.h"
-#include "lldb/Symbol/LineTable.h"
-#include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Symbol/SymbolContextScope.h"
-#include "lldb/Symbol/Type.h"
-#include "lldb/Symbol/TypeList.h"
-#include "lldb/Symbol/TypeSystem.h"
-#include "lldb/Symbol/Variable.h"
-#include "lldb/Symbol/VariableList.h"
-#include "lldb/Utility/ArchSpec.h"
-#include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Log.h"
-#include "lldb/lldb-enumerations.h"
-#include "lldb/lldb-forward.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <tuple>
-
-#define DEBUG_TYPE "symbols-backend"
-
-namespace std {
-template <>
-struct less<symbols_backend::SourceLocation> {
-  bool operator()(const symbols_backend::SourceLocation& a,
-                  const symbols_backend::SourceLocation& b) const {
-    return std::make_tuple(a.file, a.line, a.column) <
-           std::make_tuple(b.file, b.line, b.column);
-  }
-};
-
-template <>
-struct less<symbols_backend::Variable> {
-  bool operator()(const symbols_backend::Variable& a,
-                  const symbols_backend::Variable& b) const {
-    return a.name < b.name;
-  }
-};
-}  // namespace std
-
-namespace {
-static llvm::StringRef GetDWOName(DWARFCompileUnit& dwarf_cu) {
-  return dwarf_cu.GetUnitDIEOnly().GetDIE()->GetAttributeValueAsString(
-      &dwarf_cu, lldb_private::dwarf::DW_AT_dwo_name, nullptr);
-}
-}  // namespace
-
-namespace symbols_backend {
-bool operator==(const SourceLocation& a, const SourceLocation& b) {
-  return std::make_tuple(a.file, a.line, a.column) ==
-         std::make_tuple(b.file, b.line, b.column);
-}
-
-bool operator==(const symbols_backend::Variable& a,
-                const symbols_backend::Variable& b) {
-  return std::make_tuple(a.name, a.type, a.scope) ==
-         std::make_tuple(b.name, b.type, b.scope);
-}
-
-llvm::Expected<std::pair<lldb::DebuggerSP, lldb::TargetSP>> GetTarget() {
-  static std::pair<lldb::DebuggerSP, lldb::TargetSP> instance = {};
-  if (!instance.first) {
-    lldb::DebuggerSP dbg = lldb_private::Debugger::CreateInstance();
-    lldb_private::ArchSpec arch("wasm32-unknown-unknown");
-    lldb::TargetSP target;
-    lldb::PlatformSP platform = lldb_private::Platform::GetHostPlatform();
-    dbg->GetPlatformList().SetSelectedPlatform(platform);
-    auto stat = dbg->GetTargetList().CreateTarget(
-        *dbg, {}, arch, lldb_private::eLoadDependentsNo, platform, target);
-    if (stat.Fail()) {
-      return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                     stat.AsCString());
-    }
-    target->SetPreloadSymbols(false);
-    instance = {dbg, target};
-  }
-  return instance;
-}
-
-llvm::Expected<std::unique_ptr<WasmModule>> WasmModule::CreateFromFile(
-    llvm::StringRef path) {
-  if (!llvm::sys::fs::exists(path)) {
-    return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                   "Module file '%s' not found\n.",
-                                   path.str().c_str());
-  }
-  LLVM_DEBUG(llvm::dbgs() << "Loading module from '" << path << "'\n");
-
-  auto instance = GetTarget();
-  if (!instance) {
-    return instance.takeError();
-  }
-  auto [debugger, target] = *instance;
-  auto module = target->GetOrCreateModule(
-      {lldb_private::FileSpec(path),
-       lldb_private::ArchSpec("wasm32-unknown-unknown-wasm")},
-      false);
-
-  return std::unique_ptr<WasmModule>(new WasmModule(target, module));
-}
-
-bool WasmModule::Valid() const {
-  return module_ && module_->GetNumCompileUnits() > 0;
-}
-
-SourceInfo WasmModule::GetSourceScripts() const {
-  llvm::SmallSet<std::string, 1> compile_units;
-  llvm::SmallSet<std::string, 1> dwos;
-  llvm::SmallSet<std::pair<llvm::StringRef, llvm::StringRef>, 1> all_files;
-  for (size_t idx = 0; idx < module_->GetNumCompileUnits(); idx++) {
-    auto compile_unit = module_->GetCompileUnitAtIndex(idx);
-    for (auto f : compile_unit->GetSupportFiles()) {
-      auto dir = f.GetDirectory().GetStringRef();
-      auto filename = f.GetFilename().GetStringRef();
-      if (filename.empty()) {
-        continue;
-      }
-      if (!all_files.insert(std::make_pair(dir, filename)).second) {
-        continue;
-      }
-      compile_units.insert(f.GetPath());
-    }
-
-    // Cast user data to DwarfUnit
-    DWARFCompileUnit* dwarf_cu =
-        static_cast<DWARFCompileUnit*>(compile_unit->GetUserData());
-    if (dwarf_cu && dwarf_cu->GetVersion() >= 5) {
-      // Might need to lazy load this .dwo (only works for DWARF5)
-      llvm::SmallVector<std::string, 2> missing_symbols;
-      auto dwo_name = GetDWOName(*dwarf_cu);
-      if (!dwo_name.empty()) {
-        dwos.insert(dwo_name.str());
-      }
-    }
-  }
-  return {compile_units, dwos};
-}
-
-namespace {
-uint32_t GetSymbolContextFromOffset(lldb_private::Module* module,
-                                    lldb::addr_t offset,
-                                    int inline_frame_index,
-                                    lldb::SymbolContextItem resolve_scope,
-                                    lldb_private::SymbolContext& out_sc,
-                                    lldb_private::Address& out_addr) {
-  if (!module->GetObjectFile() || !module->GetObjectFile()->GetSectionList()) {
-    return 0;
-  }
-  lldb_private::SymbolContext sc;
-  sc.module_sp = module->shared_from_this();
-  lldb::SectionSP section =
-      module->GetObjectFile()->GetSectionList()->FindSectionByType(
-          lldb::eSectionTypeCode, false);
-  lldb_private::Address addr(section, offset);
-
-  auto resolved =
-      module->ResolveSymbolContextForAddress(addr, resolve_scope, sc);
-  if (inline_frame_index == 0 &&
-      (resolved & lldb::eSymbolContextBlock) != lldb::eSymbolContextBlock) {
-    out_sc = std::move(sc);
-    out_addr = std::move(addr);
-    return out_sc.GetResolvedMask();
-  }
-
-  for (int i = 0; i < inline_frame_index; i++) {
-    lldb_private::SymbolContext next_sc;
-    lldb_private::Address next_addr;
-    if (!sc.GetParentOfInlinedScope(addr, next_sc, next_addr)) {
-      return 0;
-    }
-    addr = std::move(next_addr);
-    sc = std::move(next_sc);
-    // Sometimes the inline block address range isn't properly clipped
-    // to the parent range; fix this.
-    if (addr.GetOffset() == 0 && sc.function) {
-      addr = sc.function->GetAddressRange().GetBaseAddress();
-    }
-  }
-  out_sc = std::move(sc);
-  out_addr = std::move(addr);
-  return out_sc.GetResolvedMask();
-}
-
-void GetVariablesFromOffset(lldb_private::Module* module,
-                            lldb::addr_t offset,
-                            int inline_frame_index,
-                            lldb_private::VariableList* var_list) {
-  lldb_private::SymbolContext sc;
-  lldb_private::Address addr;
-  auto resolved = GetSymbolContextFromOffset(
-      module, offset, inline_frame_index, lldb::eSymbolContextBlock, sc, addr);
-  if ((resolved & lldb::eSymbolContextBlock) == lldb::eSymbolContextBlock) {
-    sc.block->AppendVariables(
-        true, true, true,
-        [var_list](lldb_private::Variable* var) {
-          return (var_list->FindVariableIndex(lldb::VariableSP{
-                      var, [](lldb_private::Variable*) {}}) == UINT32_MAX);
-        },
-        var_list);
-  }
-  resolved = GetSymbolContextFromOffset(module, offset, inline_frame_index,
-                                        lldb::eSymbolContextCompUnit, sc, addr);
-  if ((resolved & lldb::eSymbolContextCompUnit) ==
-      lldb::eSymbolContextCompUnit) {
-    sc.comp_unit->GetVariableList(true)->AppendVariablesIfUnique(*var_list);
-  }
-}
-}  // namespace
-
-lldb::VariableSP WasmModule::FindVariableAtOffset(lldb::addr_t offset,
-                                                  int inline_frame_index,
-                                                  llvm::StringRef name) const {
-  lldb_private::VariableList var_list;
-  GetVariablesFromOffset(&*module_, offset, inline_frame_index, &var_list);
-  // GetVariablesFromOffset fills the list with variables sorted from innermost
-  // scope to outermost scope, so the first hit in the list is the correct one.
-  for (auto var : var_list) {
-    // llvm::errs() << "var: " << var.get() << "\n";
-    if (var->GetName().GetStringRef() == name) {
-      return var;
-    }
-  }
-  return {};
-}
-
-llvm::Optional<lldb_private::CompilerType> WasmModule::FindType(
-    llvm::StringRef name) const {
-  lldb_private::TypeList type_list;
-  llvm::DenseSet<lldb_private::SymbolFile*> searched_symbol_files;
-  module_->FindTypes(lldb_private::ConstString(name), true, 1,
-                     searched_symbol_files, type_list);
-  if (!type_list.Empty()) {
-    return type_list.GetTypeAtIndex(0)->GetFullCompilerType();
-  }
-  return llvm::None;
-}
-
-llvm::SmallSet<SourceLocation, 1> WasmModule::GetSourceLocationFromOffset(
-    lldb::addr_t offset,
-    int inline_frame_index) const {
-  llvm::SmallSet<SourceLocation, 1> lines;
-
-  lldb_private::Address addr;
-  lldb_private::SymbolContext sc;
-  auto resolved = GetSymbolContextFromOffset(
-      &*module_, offset, inline_frame_index,
-      lldb::eSymbolContextBlock | lldb::eSymbolContextLineEntry, sc, addr);
-  if ((resolved & lldb::eSymbolContextLineEntry) && sc.line_entry.IsValid() &&
-      sc.line_entry.line > 0) {
-    lines.insert({sc.line_entry.file.GetPath(), sc.line_entry.line,
-                  sc.line_entry.column});
-  }
-  return lines;
-}
-
-std::vector<int32_t> WasmModule::GetMappedLines(
-    llvm::StringRef file_path) const {
-  lldb_private::FileSpec::Style file_path_style =
-      lldb_private::FileSpec::GuessPathStyle(file_path).value_or(
-          lldb_private::FileSpec::Style::native);
-  lldb_private::FileSpec file_spec(file_path, file_path_style);
-  lldb_private::SymbolContextList line_entry_scs;
-
-  // Get the comp unit symbol contexts for the file.
-  for (size_t idx = 0; idx < module_->GetNumCompileUnits(); idx++) {
-    auto compile_unit = module_->GetCompileUnitAtIndex(idx);
-    uint32_t file_idx =
-        compile_unit->GetSupportFiles().FindFileIndex(0, file_spec, true);
-
-    // Gather all line entries for the compile_unit
-    lldb_private::LineTable* table = compile_unit->GetLineTable();
-    while (file_idx != UINT32_MAX) {
-      table->FineLineEntriesForFileIndex(file_idx, true, line_entry_scs);
-      file_idx = compile_unit->GetSupportFiles().FindFileIndex(file_idx + 1,
-                                                               file_spec, true);
-    }
-  }
-
-  std::vector<int32_t> line_numbers;
-  for (const lldb_private::SymbolContext& line_sc :
-       line_entry_scs.SymbolContexts()) {
-    assert(line_sc.line_entry.IsValid());
-    line_numbers.push_back(line_sc.line_entry.line);
-  }
-
-  std::sort(line_numbers.begin(), line_numbers.end());
-  auto end = std::unique(line_numbers.begin(), line_numbers.end());
-  line_numbers.resize(end - line_numbers.begin());
-
-  return line_numbers;
-}
-
-llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>
-WasmModule::GetOffsetFromSourceLocation(
-    const SourceLocation& source_loc) const {
-  llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1> locations;
-  std::vector<lldb_private::Address> output_local, output_extern;
-
-  llvm::StringRef file_path(source_loc.file);
-  lldb_private::FileSpec::Style file_path_style =
-      lldb_private::FileSpec::GuessPathStyle(file_path).value_or(
-          lldb_private::FileSpec::Style::native);
-  lldb_private::FileSpec file_spec(file_path, file_path_style);
-  lldb_private::SymbolContextList list;
-  module_->ResolveSymbolContextsForFileSpec(
-      file_spec, source_loc.line, true,
-      lldb::eSymbolContextLineEntry | lldb::eSymbolContextCompUnit, list);
-  std::vector<lldb_private::AddressRange> ranges;
-  for (lldb_private::SymbolContext sc : list.SymbolContexts()) {
-    if (!sc.line_entry.IsValid()) {
-      continue;
-    }
-
-    // Only return positions in the same line.
-    if (sc.line_entry.line != source_loc.line) {
-      continue;
-    }
-
-    // Take into account the column number here to make in-line breakpoints
-    // work.
-    if (source_loc.column && sc.line_entry.column != source_loc.column) {
-      continue;
-    }
-
-    // Check if the line entry range is already covered.
-    lldb_private::AddressRange range = sc.line_entry.range;
-    if (std::find_if(ranges.begin(), ranges.end(),
-                     [&](const lldb_private::AddressRange& r) {
-                       auto address = range.GetBaseAddress();
-                       return r.ContainsFileAddress(address);
-                     }) != ranges.end()) {
-      continue;
-    }
-
-    while (true) {
-      lldb_private::SymbolContext next_sc;
-      lldb_private::Address range_end(range.GetBaseAddress());
-      range_end.Slide(range.GetByteSize());
-      range_end.CalculateSymbolContext(&next_sc, lldb::eSymbolContextLineEntry);
-
-      // Don't combine ranges across "start of statement" markers inserted
-      // by the compiler.
-      if (!next_sc.line_entry.IsValid() ||
-          next_sc.line_entry.is_start_of_statement ||
-          next_sc.line_entry.range.GetByteSize() == 0) {
-        break;
-      }
-
-      // Include any line 0 entries, they indicate that this is compiler-
-      // generated code that does not correspond to user source code.
-      if (next_sc.line_entry.original_file != sc.line_entry.original_file ||
-          (next_sc.line_entry.line != sc.line_entry.line &&
-           next_sc.line_entry.line != 0)) {
-        break;
-      }
-
-      // Try to extend our address range to cover this line entry.
-      if (!range.Extend(next_sc.line_entry.range)) {
-        break;
-      }
-    }
-
-    ranges.push_back(range);
-  }
-
-  for (auto const& range : ranges) {
-    locations.insert({range.GetBaseAddress().GetOffset(), range.GetByteSize()});
-  }
-  return locations;
-}
-
-std::set<Variable> WasmModule::GetVariablesInScope(
-    lldb::addr_t offset,
-    int inline_frame_index) const {
-  std::set<Variable> variables;
-  lldb_private::VariableList var_list;
-  GetVariablesFromOffset(&*module_, offset, inline_frame_index, &var_list);
-  LLVM_DEBUG(llvm::dbgs() << "Found " << var_list.GetSize() << " variables\n");
-  for (auto var : var_list) {
-    var->GetSymbolContextScope()->CalculateSymbolContextCompileUnit();
-    // var_list contains variables sorted from innermost scope to outermost
-    // scope. The set compares variables by name to preserve shadowing order.
-    auto type = var->GetType();
-    variables.insert(
-        {var->GetName().GetStringRef(), var->GetScope(),
-         type ? type->GetQualifiedName().GetStringRef() : llvm::StringRef()});
-  }
-  return variables;
-}
-
-FunctionInfo WasmModule::GetFunctionInfo(lldb::addr_t offset) const {
-  llvm::SmallVector<std::string, 1> function_names;
-
-  lldb_private::SymbolContext sc, old_sc;
-  lldb_private::Address addr, old_addr;
-  auto resolved = GetSymbolContextFromOffset(
-      &*module_, offset, 0, lldb::eSymbolContextBlock, sc, addr);
-  if ((resolved & lldb::eSymbolContextBlock) == lldb::eSymbolContextBlock) {
-    do {
-      auto name = sc.GetFunctionName();
-      if (name.IsNull() || name.IsEmpty()) {
-        function_names.push_back("");
-      } else {
-        function_names.push_back(name.GetCString());
-      }
-      old_sc = std::move(sc);
-      old_addr = std::move(addr);
-    } while (old_sc.GetParentOfInlinedScope(old_addr, sc, addr));
-    return {function_names, {}};
-  } else if ((resolved & lldb::eSymbolContextCompUnit) ==
-             lldb::eSymbolContextCompUnit) {
-    // Compile unit might be missing symbols?
-
-    // Cast user data to DwarfUnit
-    DWARFCompileUnit* dwarf_cu =
-        static_cast<DWARFCompileUnit*>(sc.comp_unit->GetUserData());
-    if (dwarf_cu && dwarf_cu == &dwarf_cu->GetNonSkeletonUnit()) {
-      // The skeleton unit is the only unit, but is there supposed to be a .dwo?
-      llvm::SmallVector<std::string, 2> missing_symbols;
-      auto dwo_name = GetDWOName(*dwarf_cu);
-      if (!dwo_name.empty()) {
-        missing_symbols.push_back(dwo_name.str());
-      }
-      return {{}, missing_symbols};
-    }
-  }
-  return {{}, {}};
-}
-
-llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>
-WasmModule::GetInlineFunctionAddressRanges(lldb::addr_t offset) const {
-  llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1> ranges;
-  lldb_private::SymbolContext sc;
-  lldb_private::Address addr;
-  auto resolved = GetSymbolContextFromOffset(
-      &*module_, offset, 0, lldb::eSymbolContextBlock, sc, addr);
-  if ((resolved & lldb::eSymbolContextBlock) == lldb::eSymbolContextBlock) {
-    lldb_private::Block* inline_block = sc.block->GetContainingInlinedBlock();
-    if (inline_block) {
-      size_t count = inline_block->GetNumRanges();
-      for (size_t i = 0; i < count; i++) {
-        lldb_private::AddressRange range;
-        if (inline_block->GetRangeAtIndex(i, range)) {
-          ranges.insert(
-              {range.GetBaseAddress().GetOffset(), range.GetByteSize()});
-        }
-      }
-    }
-  }
-  return ranges;
-}
-
-llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>
-WasmModule::GetChildInlineFunctionAddressRanges(lldb::addr_t offset) const {
-  llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1> ranges;
-  lldb_private::SymbolContext sc;
-  lldb_private::Address addr;
-  auto resolved = GetSymbolContextFromOffset(
-      &*module_, offset, 0, lldb::eSymbolContextBlock, sc, addr);
-  if ((resolved & lldb::eSymbolContextBlock) == lldb::eSymbolContextBlock) {
-    // Find root block for function to search from
-    lldb_private::Block* root_block = sc.block;
-    while (!root_block->GetInlinedFunctionInfo()) {
-      lldb_private::Block* parent = root_block->GetParent();
-      if (parent) {
-        root_block = parent;
-      } else {
-        break;
-      }
-    }
-
-    // Traverse tree to find child inline blocks
-    lldb_private::Block* block = root_block->GetFirstChild();
-    while (block) {
-      lldb_private::Block* next_block = nullptr;
-      if (block->GetInlinedFunctionInfo()) {
-        size_t count = block->GetNumRanges();
-        for (size_t i = 0; i < count; i++) {
-          lldb_private::AddressRange range;
-          if (block->GetRangeAtIndex(i, range)) {
-            ranges.insert(
-                {range.GetBaseAddress().GetOffset(), range.GetByteSize()});
-          }
-        }
-      } else {
-        // Only traverse children when not an inline block
-        next_block = block->GetFirstChild();
-      }
-      // If we haven't found our next block, get a sibling
-      // or a parent's sibling
-      if (!next_block) {
-        while (true) {
-          next_block = block->GetSibling();
-          if (next_block) {
-            break;
-          }
-          block = block->GetParent();
-          if (!block || block == root_block) {
-            break;
-          }
-        }
-      }
-      block = next_block;
-    }
-  }
-  return ranges;
-}
-
-llvm::Expected<ExpressionResult> WasmModule::InterpretExpression(
-    lldb::addr_t frame_offset,
-    uint32_t inline_frame_index,
-    llvm::StringRef expression,
-    const api::DebuggerProxy& proxy) const {
-  lldb_private::SymbolContext sc;
-  lldb_private::Address addr;
-  auto resolved =
-      GetSymbolContextFromOffset(&*module_, frame_offset, inline_frame_index,
-                                 lldb::eSymbolContextEverything, sc, addr);
-
-  if ((resolved &
-       (lldb::eSymbolContextCompUnit | lldb::eSymbolContextFunction)) == 0) {
-    resolved =
-        GetSymbolContextFromOffset(&*module_, frame_offset, inline_frame_index,
-                                   lldb::eSymbolContextCompUnit, sc, addr);
-    if ((resolved & lldb::eSymbolContextCompUnit) == 0) {
-      return llvm::createStringError(
-          llvm::inconvertibleErrorCode(),
-          "Not in a valid symbol context at offset %zu", frame_offset);
-    }
-  }
-  auto type_system =
-      module_->GetTypeSystemForLanguage(sc.comp_unit->GetLanguage());
-  if (!type_system) {
-    return type_system.takeError();
-  }
-  return ::symbols_backend::InterpretExpression(
-      *this, **type_system, sc, frame_offset, inline_frame_index, addr,
-      expression, proxy);
-}
-}  // namespace symbols_backend

package/extensions/cxx_debugging/lib/WasmModule.h

@@ -1,126 +0,0 @@
-// Copyright 2023 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef EXTENSIONS_CXX_DEBUGGING_WASM_MODULE_H_
-#define EXTENSIONS_CXX_DEBUGGING_WASM_MODULE_H_
-#include "lldb/lldb-enumerations.h"
-#include "lldb/lldb-forward.h"
-#include "lldb/lldb-types.h"
-#include "llvm/ADT/SmallSet.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Error.h"
-
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace symbols_backend {
-namespace api {
-class DebuggerProxy;
-}
-class ObjectInfo;
-
-struct SourceLocation {
-  SourceLocation(llvm::StringRef file, uint32_t line, uint16_t column)
-      : file(file), line(line), column(column) {}
-
-  std::string file;
-  uint32_t line;
-  uint16_t column;
-
-  friend bool operator==(const SourceLocation&, const SourceLocation&);
-};
-
-struct Variable {
-  Variable(llvm::StringRef name, lldb::ValueType scope, llvm::StringRef type)
-      : name(name), scope(scope), type(type) {}
-
-  std::string name;
-  lldb::ValueType scope;
-  std::string type;
-
-  friend bool operator==(const Variable&, const Variable&);
-};
-
-struct FunctionInfo {
-  FunctionInfo(llvm::SmallVector<std::string, 1> names,
-               llvm::SmallVector<std::string, 2> missing_symbols)
-      : names(names), missing_symbols(missing_symbols) {}
-
-  llvm::SmallVector<std::string, 1> names;
-  llvm::SmallVector<std::string, 2> missing_symbols;
-};
-
-struct SourceInfo {
-  SourceInfo(llvm::SmallSet<std::string, 1> sources,
-             llvm::SmallSet<std::string, 1> dwos)
-      : sources(sources), dwos(dwos) {}
-
-  llvm::SmallSet<std::string, 1> sources;
-  llvm::SmallSet<std::string, 1> dwos;
-};
-
-struct ExpressionResult;
-class WasmModule {
-  lldb::ModuleSP module_;
-  lldb::TargetSP target_;
-  explicit WasmModule(lldb::TargetSP target, lldb::ModuleSP module)
-      : module_(module), target_(target) {}
-
- public:
-  ~WasmModule(){};
-  WasmModule(const WasmModule&) = delete;
-  WasmModule& operator=(const WasmModule&) = delete;
-  WasmModule(WasmModule&&) = default;
-  WasmModule& operator=(WasmModule&&) = default;
-
-  static llvm::Expected<std::unique_ptr<WasmModule>> CreateFromFile(
-      llvm::StringRef path);
-
-  bool Valid() const;
-
-  lldb_private::Module* Module() const { return module_.get(); }
-  lldb_private::Target* Target() const { return target_.get(); }
-
-  SourceInfo GetSourceScripts() const;
-  llvm::SmallSet<SourceLocation, 1> GetSourceLocationFromOffset(
-      lldb::addr_t offset,
-      int inline_frame_index) const;
-  llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>
-  GetOffsetFromSourceLocation(const SourceLocation& source_loc) const;
-  std::set<Variable> GetVariablesInScope(lldb::addr_t offset,
-                                         int inline_frame_index) const;
-  FunctionInfo GetFunctionInfo(lldb::addr_t offset) const;
-  // Returns inline function address ranges for the inline function containing
-  // offset, or an empty set if offset is not in an inline function. Used for
-  // stepping out of inline functions.
-  llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>
-  GetInlineFunctionAddressRanges(lldb::addr_t offset) const;
-  // Returns address ranges for any inline function calls made by the function
-  // or inline function containing offset. Used for stepping over inline
-  // functions.
-  llvm::SmallSet<std::pair<lldb::addr_t, lldb::addr_t>, 1>
-  GetChildInlineFunctionAddressRanges(lldb::addr_t offset) const;
-
-  std::vector<int32_t> GetMappedLines(llvm::StringRef file) const;
-
-  lldb::VariableSP FindVariableAtOffset(lldb::addr_t offset,
-                                        int inline_frame_index,
-                                        llvm::StringRef name) const;
-  llvm::Optional<lldb_private::CompilerType> FindType(
-      llvm::StringRef name) const;
-
-  llvm::Expected<ExpressionResult> InterpretExpression(
-      lldb::addr_t frame_offset,
-      uint32_t inline_frame_index,
-      llvm::StringRef expression,
-      const api::DebuggerProxy& proxy) const;
-};
-
-}  // namespace symbols_backend
-
-#endif  // EXTENSIONS_CXX_DEBUGGING_WASM_MODULE_H_