| //===-- ASTStructExtractor.h ------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef liblldb_ASTStructExtractor_h_ |
| #define liblldb_ASTStructExtractor_h_ |
| |
| #include "clang/Sema/SemaConsumer.h" |
| #include "lldb/Core/ClangForward.h" |
| #include "lldb/Expression/ClangExpressionVariable.h" |
| #include "lldb/Expression/ClangFunction.h" |
| |
| namespace lldb_private { |
| |
| //---------------------------------------------------------------------- |
| /// @class ASTStructExtractor ASTStructExtractor.h "lldb/Expression/ASTStructExtractor.h" |
| /// @brief Extracts and describes the argument structure for a wrapped function. |
| /// |
| /// This pass integrates with ClangFunction, which calls functions with custom |
| /// sets of arguments. To avoid having to implement the full calling convention |
| /// for the target's architecture, ClangFunction 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. ClangFunction friends ASTStructExtractor |
| /// for this purpose. |
| //---------------------------------------------------------------------- |
| ASTStructExtractor(clang::ASTConsumer *passthrough, |
| const char *struct_name, |
| ClangFunction &function); |
| |
| //---------------------------------------------------------------------- |
| /// Destructor |
| //---------------------------------------------------------------------- |
| virtual ~ASTStructExtractor(); |
| |
| //---------------------------------------------------------------------- |
| /// 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); |
| |
| //---------------------------------------------------------------------- |
| /// 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); |
| |
| //---------------------------------------------------------------------- |
| /// Passthrough stub |
| //---------------------------------------------------------------------- |
| void HandleTranslationUnit(clang::ASTContext &Ctx); |
| |
| //---------------------------------------------------------------------- |
| /// Passthrough stub |
| //---------------------------------------------------------------------- |
| void HandleTagDeclDefinition(clang::TagDecl *D); |
| |
| //---------------------------------------------------------------------- |
| /// Passthrough stub |
| //---------------------------------------------------------------------- |
| void CompleteTentativeDefinition(clang::VarDecl *D); |
| |
| //---------------------------------------------------------------------- |
| /// Passthrough stub |
| //---------------------------------------------------------------------- |
| void HandleVTable(clang::CXXRecordDecl *RD, bool DefinitionRequired); |
| |
| //---------------------------------------------------------------------- |
| /// Passthrough stub |
| //---------------------------------------------------------------------- |
| void PrintStats(); |
| |
| //---------------------------------------------------------------------- |
| /// 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); |
| |
| //---------------------------------------------------------------------- |
| /// Reset the Sema to NULL now that transformations are done |
| //---------------------------------------------------------------------- |
| void ForgetSema(); |
| 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. |
| clang::Action *m_action; ///< The Sema to use, cast to an Action so it's usable. |
| |
| ClangFunction &m_function; ///< The function to populate with information about the argument structure. |
| std::string m_struct_name; ///< The name of the structure to extract. |
| }; |
| |
| } |
| |
| #endif |