| //===-- ASTStructExtractor.cpp ----------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "stdlib.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclCXX.h" |
| #include "clang/AST/DeclGroup.h" |
| #include "clang/AST/Expr.h" |
| #include "clang/AST/RecordLayout.h" |
| #include "clang/AST/Stmt.h" |
| #include "clang/Parse/Parser.h" |
| #include "clang/Sema/Sema.h" |
| #include "llvm/Support/Casting.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include "lldb/Core/Log.h" |
| #include "lldb/Expression/ASTStructExtractor.h" |
| |
| using namespace llvm; |
| using namespace clang; |
| using namespace lldb_private; |
| |
| ASTStructExtractor::ASTStructExtractor(ASTConsumer *passthrough, |
| const char *struct_name, |
| ClangFunction &function) : |
| m_ast_context (NULL), |
| m_passthrough (passthrough), |
| m_passthrough_sema (NULL), |
| m_sema (NULL), |
| m_action (NULL), |
| m_function (function), |
| m_struct_name (struct_name) |
| { |
| if (!m_passthrough) |
| return; |
| |
| m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough); |
| } |
| |
| ASTStructExtractor::~ASTStructExtractor() |
| { |
| } |
| |
| void |
| ASTStructExtractor::Initialize(ASTContext &Context) |
| { |
| m_ast_context = &Context; |
| |
| if (m_passthrough) |
| m_passthrough->Initialize(Context); |
| } |
| |
| void |
| ASTStructExtractor::ExtractFromFunctionDecl(FunctionDecl *F) |
| { |
| if (!F->hasBody()) |
| return; |
| |
| Stmt *body_stmt = F->getBody(); |
| CompoundStmt *body_compound_stmt = dyn_cast<CompoundStmt>(body_stmt); |
| |
| if (!body_compound_stmt) |
| return; // do we have to handle this? |
| |
| RecordDecl *struct_decl = NULL; |
| |
| StringRef desired_name(m_struct_name.c_str()); |
| |
| for (CompoundStmt::const_body_iterator bi = body_compound_stmt->body_begin(), be = body_compound_stmt->body_end(); |
| bi != be; |
| ++bi) |
| { |
| Stmt *curr_stmt = *bi; |
| DeclStmt *curr_decl_stmt = dyn_cast<DeclStmt>(curr_stmt); |
| if (!curr_decl_stmt) |
| continue; |
| DeclGroupRef decl_group = curr_decl_stmt->getDeclGroup(); |
| for (Decl *candidate_decl : decl_group) |
| { |
| RecordDecl *candidate_record_decl = dyn_cast<RecordDecl>(candidate_decl); |
| if (!candidate_record_decl) |
| continue; |
| if (candidate_record_decl->getName() == desired_name) |
| { |
| struct_decl = candidate_record_decl; |
| break; |
| } |
| } |
| if (struct_decl) |
| break; |
| } |
| |
| if (!struct_decl) |
| return; |
| |
| const ASTRecordLayout* struct_layout(&m_ast_context->getASTRecordLayout (struct_decl)); |
| |
| if (!struct_layout) |
| return; |
| |
| m_function.m_struct_size = struct_layout->getSize().getQuantity(); // TODO Store m_struct_size as CharUnits |
| m_function.m_return_offset = struct_layout->getFieldOffset(struct_layout->getFieldCount() - 1) / 8; |
| m_function.m_return_size = struct_layout->getDataSize().getQuantity() - m_function.m_return_offset; |
| |
| for (unsigned field_index = 0, num_fields = struct_layout->getFieldCount(); |
| field_index < num_fields; |
| ++field_index) |
| { |
| m_function.m_member_offsets.push_back(struct_layout->getFieldOffset(field_index) / 8); |
| } |
| |
| m_function.m_struct_valid = true; |
| } |
| |
| void |
| ASTStructExtractor::ExtractFromTopLevelDecl(Decl* D) |
| { |
| LinkageSpecDecl *linkage_spec_decl = dyn_cast<LinkageSpecDecl>(D); |
| |
| if (linkage_spec_decl) |
| { |
| RecordDecl::decl_iterator decl_iterator; |
| |
| for (decl_iterator = linkage_spec_decl->decls_begin(); |
| decl_iterator != linkage_spec_decl->decls_end(); |
| ++decl_iterator) |
| { |
| ExtractFromTopLevelDecl(*decl_iterator); |
| } |
| } |
| |
| FunctionDecl *function_decl = dyn_cast<FunctionDecl>(D); |
| |
| if (m_ast_context && |
| function_decl && |
| !m_function.m_wrapper_function_name.compare(function_decl->getNameAsString().c_str())) |
| { |
| ExtractFromFunctionDecl(function_decl); |
| } |
| } |
| |
| bool |
| ASTStructExtractor::HandleTopLevelDecl(DeclGroupRef D) |
| { |
| DeclGroupRef::iterator decl_iterator; |
| |
| for (decl_iterator = D.begin(); |
| decl_iterator != D.end(); |
| ++decl_iterator) |
| { |
| Decl *decl = *decl_iterator; |
| |
| ExtractFromTopLevelDecl(decl); |
| } |
| |
| if (m_passthrough) |
| return m_passthrough->HandleTopLevelDecl(D); |
| return true; |
| } |
| |
| void |
| ASTStructExtractor::HandleTranslationUnit(ASTContext &Ctx) |
| { |
| if (m_passthrough) |
| m_passthrough->HandleTranslationUnit(Ctx); |
| } |
| |
| void |
| ASTStructExtractor::HandleTagDeclDefinition(TagDecl *D) |
| { |
| if (m_passthrough) |
| m_passthrough->HandleTagDeclDefinition(D); |
| } |
| |
| void |
| ASTStructExtractor::CompleteTentativeDefinition(VarDecl *D) |
| { |
| if (m_passthrough) |
| m_passthrough->CompleteTentativeDefinition(D); |
| } |
| |
| void |
| ASTStructExtractor::HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) |
| { |
| if (m_passthrough) |
| m_passthrough->HandleVTable(RD, DefinitionRequired); |
| } |
| |
| void |
| ASTStructExtractor::PrintStats() |
| { |
| if (m_passthrough) |
| m_passthrough->PrintStats(); |
| } |
| |
| void |
| ASTStructExtractor::InitializeSema(Sema &S) |
| { |
| m_sema = &S; |
| m_action = reinterpret_cast<Action*>(m_sema); |
| |
| if (m_passthrough_sema) |
| m_passthrough_sema->InitializeSema(S); |
| } |
| |
| void |
| ASTStructExtractor::ForgetSema() |
| { |
| m_sema = NULL; |
| m_action = NULL; |
| |
| if (m_passthrough_sema) |
| m_passthrough_sema->ForgetSema(); |
| } |