apply lldb-wasm.patch from wamr

wamr commit b75ae3363da4da7039faec62decd14b6b07f666e

Author: yamt

lldb/include/lldb/Core/Module.h

@@ -41,6 +41,7 @@
 
 namespace lldb_private {
 class CompilerDeclContext;
+class DWARFEvaluatorFactory;
 class Function;
 class Log;
 class ObjectFile;
@@ -859,6 +860,8 @@ class Module : public std::enable_shared_from_this<Module>,
   /// Update the ArchSpec to a more specific variant.
   bool MergeArchitecture(const ArchSpec &arch_spec);
 
+  DWARFEvaluatorFactory *GetDWARFExpressionEvaluatorFactory();
+
   /// \class LookupInfo Module.h "lldb/Core/Module.h"
   /// A class that encapsulates name lookup information.
   ///
@@ -985,6 +988,8 @@ class Module : public std::enable_shared_from_this<Module>,
       m_first_file_changed_log : 1; /// See if the module was modified after it
                                     /// was initially opened.
 
+  std::unique_ptr<DWARFEvaluatorFactory> m_dwarf_evaluator_factory;
+
   /// Resolve a file or load virtual address.
   ///
   /// Tries to resolve \a vm_addr as a file address (if \a

lldb/include/lldb/Core/PluginManager.h

@@ -508,6 +508,17 @@ class PluginManager {
   static bool CreateSettingForStructuredDataPlugin(
       Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
       ConstString description, bool is_global_property);
+
+  // DWARFEvaluatorFactory
+  static bool
+  RegisterPlugin(ConstString name, const char *description,
+                 DWARFEvaluatorFactoryCreateInstance create_callback);
+
+  static bool
+  UnregisterPlugin(DWARFEvaluatorFactoryCreateInstance create_callback);
+
+  static DWARFEvaluatorFactoryCreateInstance
+  GetDWARFEvaluatorFactoryCreateCallbackAtIndex(uint32_t idx);
 };
 
 } // namespace lldb_private

lldb/include/lldb/Expression/DWARFEvaluator.h

@@ -0,0 +1,110 @@
+//===-- DWARFEvaluator.h ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_EXPRESSION_DWARFEVALUATOR_H
+#define LLDB_EXPRESSION_DWARFEVALUATOR_H
+
+#include "lldb/lldb-private.h"
+#include <vector>
+
+namespace lldb_private {
+
+class DWARFExpression;
+
+/// \class DWARFEvaluator DWARFEvaluator.h
+/// "lldb/Expression/DWARFEvaluator.h" Evaluates DWARF opcodes.
+///
+class DWARFEvaluator {
+public:
+  /// Crates a DWARF location expression evaluator
+  ///
+  /// \param[in] dwarf_expression
+  ///     The DWARF expression to evaluate.
+  ///
+  /// \param[in] exe_ctx
+  ///     The execution context in which to evaluate the location
+  ///     expression.  The location expression may access the target's
+  ///     memory, especially if it comes from the expression parser.
+  ///
+  ///  \param[in] reg_ctx
+  ///     An optional parameter which provides a RegisterContext for use
+  ///     when evaluating the expression (i.e. for fetching register values).
+  ///     Normally this will come from the ExecutionContext's StackFrame but
+  ///     in the case where an expression needs to be evaluated while building
+  ///     the stack frame list, this short-cut is available.
+  ///
+  /// \param[in] initial_value_ptr
+  ///     A value to put on top of the interpreter stack before evaluating
+  ///     the expression, if the expression is parametrized.  Can be NULL.
+  ///
+  /// \param[in] object_address_ptr
+  ///
+  DWARFEvaluator(const DWARFExpression &dwarf_expression,
+                 ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
+                 const Value *initial_value_ptr,
+                 const Value *object_address_ptr);
+
+  /// DWARFEvaluator protocol.
+  /// \{
+
+  /// Evaluate the DWARF location expression
+  ///
+  /// \param[in] result
+  ///     A value into which the result of evaluating the expression is
+  ///     to be placed.
+  ///
+  /// \param[in] error_ptr
+  ///     If non-NULL, used to report errors in expression evaluation.
+  ///
+  /// \return
+  ///     True on success; false otherwise.  If error_ptr is non-NULL,
+  ///     details of the failure are provided through it.
+  virtual bool Evaluate(Value &result, Status *error_ptr);
+
+  /// Evaluate the DWARF location expression with the opcodes specified.
+  ///
+  /// \param[in] opcodes
+  ///     The DWARF opcodes to evaluate.
+  ///
+  /// \param[in] result
+  ///     A value into which the result of evaluating the expression is
+  ///     to be placed.
+  ///
+  /// \param[in] error_ptr
+  ///     If non-NULL, used to report errors in expression evaluation.
+  ///
+  /// \return
+  ///     True on success; false otherwise.  If error_ptr is non-NULL,
+  ///     details of the failure are provided through it.
+  virtual bool Evaluate(const DataExtractor &opcodes, Value &result,
+                        Status *error_ptr);
+
+  /// Evaluates a specific DWARF opcode in the context of a DWARF expression
+  virtual bool Evaluate(const uint8_t op, Process *process, StackFrame *frame,
+                        std::vector<Value> &stack, const DataExtractor &opcodes,
+                        lldb::offset_t &offset, Value &pieces,
+                        uint64_t &op_piece_offset, Log *log, Status *error_ptr);
+
+  /// \}
+
+protected:
+  const DWARFExpression &m_dwarf_expression;
+  ExecutionContext *m_exe_ctx;
+  RegisterContext *m_reg_ctx;
+  const Value *m_initial_value_ptr;
+  const Value *m_object_address_ptr;
+
+private:
+  DWARFEvaluator(const DWARFEvaluator &);
+  const DWARFEvaluator &operator=(const DWARFEvaluator &) = delete;
+
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_EXPRESSION_DWARFEVALUATOR_H

lldb/include/lldb/Expression/DWARFEvaluatorFactory.h

@@ -0,0 +1,56 @@
+//===-- DWARFEvaluatorFactory.h ---------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_EXPRESSION_DWARFEVALUATORFACTORY_H
+#define LLDB_EXPRESSION_DWARFEVALUATORFACTORY_H
+
+#include "lldb/Core/PluginInterface.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/lldb-private.h"
+
+class DWARFUnit;
+
+namespace lldb_private {
+
+class DWARFEvaluator;
+class DWARFExpression;
+
+/// \class DWARFEvaluatorFactory DWARFEvaluatorFactory.h
+/// "lldb/Expression/DWARFEvaluatorFactory.h" Factory class that allows the
+/// registration of platform-specific DWARF expression evaluators, used to
+/// handle platform-specific DWARF opcodes.
+class DWARFEvaluatorFactory : public PluginInterface {
+public:
+  static std::unique_ptr<DWARFEvaluatorFactory> FindPlugin(Module *module);
+
+  /// PluginInterface protocol.
+  /// \{
+  ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override { return 1; }
+  /// \}
+
+  DWARFEvaluatorFactory() {}
+
+  /// DWARFEvaluatorFactory protocol.
+  /// \{
+  virtual std::unique_ptr<DWARFEvaluator>
+  CreateDWARFEvaluator(const DWARFExpression &dwarf_expression,
+                       ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
+                       const Value *initial_value_ptr,
+                       const Value *object_address_ptr);
+  /// \}
+
+private:
+  DWARFEvaluatorFactory(const DWARFEvaluatorFactory &);
+  const DWARFEvaluatorFactory &operator=(const DWARFEvaluatorFactory &) = delete;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_EXPRESSION_DWARFEVALUATORFACTORY_H

lldb/include/lldb/Expression/DWARFExpression.h

@@ -120,6 +120,10 @@ class DWARFExpression {
 
   void SetModule(const lldb::ModuleSP &module) { m_module_wp = module; }
 
+  lldb::ModuleSP GetModule() const { return m_module_wp.lock(); }
+
+  const DWARFUnit *GetDWARFCompileUnit() const { return m_dwarf_cu; }
+
   bool ContainsThreadLocalStorage() const;
 
   bool LinkThreadLocalStorage(
@@ -140,7 +144,7 @@ class DWARFExpression {
                                 lldb::addr_t func_file_addr);
 
   /// Return the call-frame-info style register kind
-  int GetRegisterKind();
+  lldb::RegisterKind  GetRegisterKind() const;
 
   /// Set the call-frame-info style register kind
   ///
@@ -219,6 +223,9 @@ class DWARFExpression {
 
   bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op);
 
+  static lldb::addr_t ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
+                                                      uint32_t index);
+
   llvm::Optional<DataExtractor>
   GetLocationExpression(lldb::addr_t load_function_start,
                         lldb::addr_t addr) const;

lldb/include/lldb/Target/Process.h

@@ -1434,7 +1434,7 @@ class Process : public std::enable_shared_from_this<Process>,
   ///     vm_addr, \a buf, and \a size updated appropriately. Zero is
   ///     returned in the case of an error.
   virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
-                            Status &error);
+                            Status &error, ExecutionContext *exe_ctx = nullptr);
 
   /// Read of memory from a process.
   ///

lldb/include/lldb/Target/ProcessTrace.h

@@ -59,7 +59,7 @@ class ProcessTrace : public PostMortemProcess {
   bool WarnBeforeDetach() const override { return false; }
 
   size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
-                    Status &error) override;
+                    Status &error, ExecutionContext *exe_ctx = nullptr) override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       Status &error) override;

lldb/include/lldb/lldb-forward.h

@@ -74,6 +74,7 @@ class Disassembler;
 class DumpValueObjectOptions;
 class DynamicCheckerFunctions;
 class DynamicLoader;
+class DWARFEvaluatorFactory;
 class Editline;
 class EmulateInstruction;
 class Environment;

lldb/include/lldb/lldb-private-interfaces.h

@@ -113,6 +113,8 @@ typedef lldb::REPLSP (*REPLCreateInstance)(Status &error,
                                            const char *repl_options);
 typedef int (*ComparisonFunction)(const void *, const void *);
 typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
+typedef DWARFEvaluatorFactory *(*DWARFEvaluatorFactoryCreateInstance)(
+    Module *module);
 /// Trace
 /// \{
 typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceForSessionFile)(

lldb/source/Core/Module.cpp

@@ -16,6 +16,7 @@
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Expression/DWARFEvaluatorFactory.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
@@ -1659,3 +1660,9 @@ bool Module::GetIsDynamicLinkEditor() {
 
   return false;
 }
+
+DWARFEvaluatorFactory *Module::GetDWARFExpressionEvaluatorFactory() {
+  if (!m_dwarf_evaluator_factory)
+    m_dwarf_evaluator_factory = DWARFEvaluatorFactory::FindPlugin(this);
+  return m_dwarf_evaluator_factory.get();
+}