1 files changed, 131 insertions, 0 deletions
diff --git a/contrib/llvm-project/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h b/contrib/llvm-project/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h
new file mode 100644
index 000000000000..c285f6408895
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h
@@ -0,0 +1,131 @@
+//===-- ASTStructExtractor.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_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTSTRUCTEXTRACTOR_H
+#define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTSTRUCTEXTRACTOR_H
+
+#include "ClangExpressionVariable.h"
+#include "ClangFunctionCaller.h"
+
+#include "clang/Sema/SemaConsumer.h"
+
+namespace lldb_private {
+
+/// \class ASTStructExtractor ASTStructExtractor.h
+/// "lldb/Expression/ASTStructExtractor.h" Extracts and describes the argument
+/// structure for a wrapped function.
+///
+/// This pass integrates with ClangFunctionCaller, which calls functions with
+/// custom sets of arguments.  To avoid having to implement the full calling
+/// convention for the target's architecture, ClangFunctionCaller writes a
+/// simple wrapper function that takes a pointer to an argument structure that
+/// contains room for the address of the function to be called, the values of
+/// all its arguments, and room for the function's return value.
+///
+/// The definition of this struct is itself in the body of the wrapper
+/// function, so Clang does the structure layout itself.  ASTStructExtractor
+/// reads through the AST for the wrapper function and finds the struct.
+class ASTStructExtractor : public clang::SemaConsumer {
+public:
+  /// Constructor
+  ///
+  /// \param[in] passthrough
+  ///     Since the ASTs must typically go through to the Clang code generator
+  ///     in order to produce LLVM IR, this SemaConsumer must allow them to
+  ///     pass to the next step in the chain after processing.  Passthrough is
+  ///     the next ASTConsumer, or NULL if none is required.
+  ///
+  /// \param[in] struct_name
+  ///     The name of the structure to extract from the wrapper function.
+  ///
+  /// \param[in] function
+  ///     The caller object whose members should be populated with information
+  ///     about the argument struct.  ClangFunctionCaller friends
+  ///     ASTStructExtractor
+  ///     for this purpose.
+  ASTStructExtractor(clang::ASTConsumer *passthrough, const char *struct_name,
+                     ClangFunctionCaller &function);
+
+  /// Destructor
+  ~ASTStructExtractor() override;
+
+  /// Link this consumer with a particular AST context
+  ///
+  /// \param[in] Context
+  ///     This AST context will be used for types and identifiers, and also
+  ///     forwarded to the passthrough consumer, if one exists.
+  void Initialize(clang::ASTContext &Context) override;
+
+  /// Examine a list of Decls to find the function $__lldb_expr and transform
+  /// its code
+  ///
+  /// \param[in] D
+  ///     The list of Decls to search.  These may contain LinkageSpecDecls,
+  ///     which need to be searched recursively.  That job falls to
+  ///     TransformTopLevelDecl.
+  bool HandleTopLevelDecl(clang::DeclGroupRef D) override;
+
+  /// Passthrough stub
+  void HandleTranslationUnit(clang::ASTContext &Ctx) override;
+
+  /// Passthrough stub
+  void HandleTagDeclDefinition(clang::TagDecl *D) override;
+
+  /// Passthrough stub
+  void CompleteTentativeDefinition(clang::VarDecl *D) override;
+
+  /// Passthrough stub
+  void HandleVTable(clang::CXXRecordDecl *RD) override;
+
+  /// Passthrough stub
+  void PrintStats() override;
+
+  /// Set the Sema object to use when performing transforms, and pass it on
+  ///
+  /// \param[in] S
+  ///     The Sema to use.  Because Sema isn't externally visible, this class
+  ///     casts it to an Action for actual use.
+  void InitializeSema(clang::Sema &S) override;
+
+  /// Reset the Sema to NULL now that transformations are done
+  void ForgetSema() override;
+
+private:
+  /// Hunt the given FunctionDecl for the argument struct and place
+  /// information about it into m_function
+  ///
+  /// \param[in] F
+  ///     The FunctionDecl to hunt.
+  void ExtractFromFunctionDecl(clang::FunctionDecl *F);
+
+  /// Hunt the given Decl for FunctionDecls named the same as the wrapper
+  /// function name, recursing as necessary through LinkageSpecDecls, and
+  /// calling ExtractFromFunctionDecl on anything that was found
+  ///
+  /// \param[in] D
+  ///     The Decl to hunt.
+  void ExtractFromTopLevelDecl(clang::Decl *D);
+
+  clang::ASTContext
+      *m_ast_context; ///< The AST context to use for identifiers and types.
+  clang::ASTConsumer *m_passthrough; ///< The ASTConsumer down the chain, for
+                                     ///passthrough.  NULL if it's a
+                                     ///SemaConsumer.
+  clang::SemaConsumer *m_passthrough_sema; ///< The SemaConsumer down the chain,
+                                           ///for passthrough.  NULL if it's an
+                                           ///ASTConsumer.
+  clang::Sema *m_sema;                     ///< The Sema to use.
+
+  ClangFunctionCaller &m_function; ///< The function to populate with
+                                   ///information about the argument structure.
+  std::string m_struct_name;       ///< The name of the structure to extract.
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTSTRUCTEXTRACTOR_H