//===-- 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 funtion 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. //---------------------------------------------------------------------- void 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