1 //===-- ASTResultSynthesizer.cpp --------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "ASTResultSynthesizer.h"
12 #include "ClangPersistentVariables.h"
14 #include "lldb/Core/Log.h"
15 #include "lldb/Symbol/ClangASTContext.h"
16 #include "lldb/Symbol/ClangASTImporter.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Utility/LLDBAssert.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclCXX.h"
23 #include "clang/AST/DeclGroup.h"
24 #include "clang/AST/DeclObjC.h"
25 #include "clang/AST/Expr.h"
26 #include "clang/AST/Stmt.h"
27 #include "clang/Parse/Parser.h"
28 #include "clang/Sema/SemaDiagnostic.h"
29 #include "llvm/Support/Casting.h"
30 #include "llvm/Support/raw_ostream.h"
33 using namespace clang;
34 using namespace lldb_private;
36 ASTResultSynthesizer::ASTResultSynthesizer(ASTConsumer *passthrough,
37 bool top_level, Target &target)
38 : m_ast_context(NULL), m_passthrough(passthrough), m_passthrough_sema(NULL),
39 m_target(target), m_sema(NULL), m_top_level(top_level) {
43 m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough);
46 ASTResultSynthesizer::~ASTResultSynthesizer() {}
48 void ASTResultSynthesizer::Initialize(ASTContext &Context) {
49 m_ast_context = &Context;
52 m_passthrough->Initialize(Context);
55 void ASTResultSynthesizer::TransformTopLevelDecl(Decl *D) {
56 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
58 if (NamedDecl *named_decl = dyn_cast<NamedDecl>(D)) {
59 if (log && log->GetVerbose()) {
60 if (named_decl->getIdentifier())
61 log->Printf("TransformTopLevelDecl(%s)",
62 named_decl->getIdentifier()->getNameStart());
63 else if (ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(D))
64 log->Printf("TransformTopLevelDecl(%s)",
65 method_decl->getSelector().getAsString().c_str());
67 log->Printf("TransformTopLevelDecl(<complex>)");
71 RecordPersistentDecl(named_decl);
75 if (LinkageSpecDecl *linkage_spec_decl = dyn_cast<LinkageSpecDecl>(D)) {
76 RecordDecl::decl_iterator decl_iterator;
78 for (decl_iterator = linkage_spec_decl->decls_begin();
79 decl_iterator != linkage_spec_decl->decls_end(); ++decl_iterator) {
80 TransformTopLevelDecl(*decl_iterator);
82 } else if (!m_top_level) {
83 if (ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(D)) {
85 !method_decl->getSelector().getAsString().compare("$__lldb_expr:")) {
86 RecordPersistentTypes(method_decl);
87 SynthesizeObjCMethodResult(method_decl);
89 } else if (FunctionDecl *function_decl = dyn_cast<FunctionDecl>(D)) {
91 !function_decl->getNameInfo().getAsString().compare("$__lldb_expr")) {
92 RecordPersistentTypes(function_decl);
93 SynthesizeFunctionResult(function_decl);
99 bool ASTResultSynthesizer::HandleTopLevelDecl(DeclGroupRef D) {
100 DeclGroupRef::iterator decl_iterator;
102 for (decl_iterator = D.begin(); decl_iterator != D.end(); ++decl_iterator) {
103 Decl *decl = *decl_iterator;
105 TransformTopLevelDecl(decl);
109 return m_passthrough->HandleTopLevelDecl(D);
113 bool ASTResultSynthesizer::SynthesizeFunctionResult(FunctionDecl *FunDecl) {
114 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
119 FunctionDecl *function_decl = FunDecl;
124 if (log && log->GetVerbose()) {
126 raw_string_ostream os(s);
128 function_decl->print(os);
132 log->Printf("Untransformed function AST:\n%s", s.c_str());
135 Stmt *function_body = function_decl->getBody();
136 CompoundStmt *compound_stmt = dyn_cast<CompoundStmt>(function_body);
138 bool ret = SynthesizeBodyResult(compound_stmt, function_decl);
140 if (log && log->GetVerbose()) {
142 raw_string_ostream os(s);
144 function_decl->print(os);
148 log->Printf("Transformed function AST:\n%s", s.c_str());
154 bool ASTResultSynthesizer::SynthesizeObjCMethodResult(
155 ObjCMethodDecl *MethodDecl) {
156 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
164 if (log && log->GetVerbose()) {
166 raw_string_ostream os(s);
168 MethodDecl->print(os);
172 log->Printf("Untransformed method AST:\n%s", s.c_str());
175 Stmt *method_body = MethodDecl->getBody();
180 CompoundStmt *compound_stmt = dyn_cast<CompoundStmt>(method_body);
182 bool ret = SynthesizeBodyResult(compound_stmt, MethodDecl);
184 if (log && log->GetVerbose()) {
186 raw_string_ostream os(s);
188 MethodDecl->print(os);
192 log->Printf("Transformed method AST:\n%s", s.c_str());
198 bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
200 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
202 ASTContext &Ctx(*m_ast_context);
207 if (Body->body_empty())
210 Stmt **last_stmt_ptr = Body->body_end() - 1;
211 Stmt *last_stmt = *last_stmt_ptr;
213 while (dyn_cast<NullStmt>(last_stmt)) {
214 if (last_stmt_ptr != Body->body_begin()) {
216 last_stmt = *last_stmt_ptr;
222 Expr *last_expr = dyn_cast<Expr>(last_stmt);
225 // No auxiliary variable necessary; expression returns void
228 // In C++11, last_expr can be a LValueToRvalue implicit cast. Strip that off
233 ImplicitCastExpr *implicit_cast = dyn_cast<ImplicitCastExpr>(last_expr);
238 if (implicit_cast->getCastKind() != CK_LValueToRValue)
241 last_expr = implicit_cast->getSubExpr();
244 // is_lvalue is used to record whether the expression returns an assignable
246 // Rvalue. This is relevant because they are handled differently.
250 // - In AST result synthesis (here!) the expression E is transformed into an
252 // T *$__lldb_expr_result_ptr = &E.
254 // - In structure allocation, a pointer-sized slot is allocated in the
255 // struct that is to be
256 // passed into the expression.
258 // - In IR transformations, reads and writes to $__lldb_expr_result_ptr are
260 // an entry in the struct ($__lldb_arg) passed into the expression.
262 // variables are treated similarly, having been materialized as
263 // references, but in those
264 // cases the value of the reference itself is never modified.)
266 // - During materialization, $0 (the result persistent variable) is ignored.
268 // - During dematerialization, $0 is marked up as a load address with value
270 // contents of the structure entry.
274 // - In AST result synthesis the expression E is transformed into an
276 // static T $__lldb_expr_result = E.
278 // - In structure allocation, a pointer-sized slot is allocated in the
279 // struct that is to be
280 // passed into the expression.
282 // - In IR transformations, an instruction is inserted at the beginning of
284 // dereference the pointer resident in the slot. Reads and writes to
285 // $__lldb_expr_result
286 // are redirected at that dereferenced version. Guard variables for the
290 // - During materialization, $0 (the result persistent variable) is
291 // populated with the location
292 // of a newly-allocated area of memory.
294 // - During dematerialization, $0 is ignored.
296 bool is_lvalue = (last_expr->getValueKind() == VK_LValue ||
297 last_expr->getValueKind() == VK_XValue) &&
298 (last_expr->getObjectKind() == OK_Ordinary);
300 QualType expr_qual_type = last_expr->getType();
301 const clang::Type *expr_type = expr_qual_type.getTypePtr();
306 if (expr_type->isVoidType())
310 std::string s = expr_qual_type.getAsString();
312 log->Printf("Last statement is an %s with type: %s",
313 (is_lvalue ? "lvalue" : "rvalue"), s.c_str());
316 clang::VarDecl *result_decl = NULL;
319 IdentifierInfo *result_ptr_id;
321 if (expr_type->isFunctionType())
323 &Ctx.Idents.get("$__lldb_expr_result"); // functions actually should
324 // be treated like function
327 result_ptr_id = &Ctx.Idents.get("$__lldb_expr_result_ptr");
329 m_sema->RequireCompleteType(SourceLocation(), expr_qual_type,
330 clang::diag::err_incomplete_type);
332 QualType ptr_qual_type;
334 if (expr_qual_type->getAs<ObjCObjectType>() != NULL)
335 ptr_qual_type = Ctx.getObjCObjectPointerType(expr_qual_type);
337 ptr_qual_type = Ctx.getPointerType(expr_qual_type);
340 VarDecl::Create(Ctx, DC, SourceLocation(), SourceLocation(),
341 result_ptr_id, ptr_qual_type, NULL, SC_Static);
346 ExprResult address_of_expr =
347 m_sema->CreateBuiltinUnaryOp(SourceLocation(), UO_AddrOf, last_expr);
348 if (address_of_expr.get())
349 m_sema->AddInitializerToDecl(result_decl, address_of_expr.get(), true);
353 IdentifierInfo &result_id = Ctx.Idents.get("$__lldb_expr_result");
355 result_decl = VarDecl::Create(Ctx, DC, SourceLocation(), SourceLocation(),
356 &result_id, expr_qual_type, NULL, SC_Static);
361 m_sema->AddInitializerToDecl(result_decl, last_expr, true);
364 DC->addDecl(result_decl);
366 ///////////////////////////////
367 // call AddInitializerToDecl
370 // m_sema->AddInitializerToDecl(result_decl, last_expr);
372 /////////////////////////////////
373 // call ConvertDeclToDeclGroup
376 Sema::DeclGroupPtrTy result_decl_group_ptr;
378 result_decl_group_ptr = m_sema->ConvertDeclToDeclGroup(result_decl);
380 ////////////////////////
381 // call ActOnDeclStmt
384 StmtResult result_initialization_stmt_result(m_sema->ActOnDeclStmt(
385 result_decl_group_ptr, SourceLocation(), SourceLocation()));
387 ////////////////////////////////////////////////
388 // replace the old statement with the new one
392 reinterpret_cast<Stmt *>(result_initialization_stmt_result.get());
397 void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) {
399 m_passthrough->HandleTranslationUnit(Ctx);
402 void ASTResultSynthesizer::RecordPersistentTypes(DeclContext *FunDeclCtx) {
403 typedef DeclContext::specific_decl_iterator<TypeDecl> TypeDeclIterator;
405 for (TypeDeclIterator i = TypeDeclIterator(FunDeclCtx->decls_begin()),
406 e = TypeDeclIterator(FunDeclCtx->decls_end());
408 MaybeRecordPersistentType(*i);
412 void ASTResultSynthesizer::MaybeRecordPersistentType(TypeDecl *D) {
413 if (!D->getIdentifier())
416 StringRef name = D->getName();
418 if (name.size() == 0 || name[0] != '$')
421 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
423 ConstString name_cs(name.str().c_str());
426 log->Printf("Recording persistent type %s\n", name_cs.GetCString());
428 m_decls.push_back(D);
431 void ASTResultSynthesizer::RecordPersistentDecl(NamedDecl *D) {
432 lldbassert(m_top_level);
434 if (!D->getIdentifier())
437 StringRef name = D->getName();
439 if (name.size() == 0)
442 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
444 ConstString name_cs(name.str().c_str());
447 log->Printf("Recording persistent decl %s\n", name_cs.GetCString());
449 m_decls.push_back(D);
452 void ASTResultSynthesizer::CommitPersistentDecls() {
453 for (clang::NamedDecl *decl : m_decls) {
454 StringRef name = decl->getName();
455 ConstString name_cs(name.str().c_str());
457 Decl *D_scratch = m_target.GetClangASTImporter()->DeportDecl(
458 m_target.GetScratchClangASTContext()->getASTContext(), m_ast_context,
462 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
466 llvm::raw_string_ostream ss(s);
470 log->Printf("Couldn't commit persistent decl: %s\n", s.c_str());
476 if (NamedDecl *NamedDecl_scratch = dyn_cast<NamedDecl>(D_scratch))
477 llvm::cast<ClangPersistentVariables>(
478 m_target.GetPersistentExpressionStateForLanguage(
479 lldb::eLanguageTypeC))
480 ->RegisterPersistentDecl(name_cs, NamedDecl_scratch);
484 void ASTResultSynthesizer::HandleTagDeclDefinition(TagDecl *D) {
486 m_passthrough->HandleTagDeclDefinition(D);
489 void ASTResultSynthesizer::CompleteTentativeDefinition(VarDecl *D) {
491 m_passthrough->CompleteTentativeDefinition(D);
494 void ASTResultSynthesizer::HandleVTable(CXXRecordDecl *RD) {
496 m_passthrough->HandleVTable(RD);
499 void ASTResultSynthesizer::PrintStats() {
501 m_passthrough->PrintStats();
504 void ASTResultSynthesizer::InitializeSema(Sema &S) {
507 if (m_passthrough_sema)
508 m_passthrough_sema->InitializeSema(S);
511 void ASTResultSynthesizer::ForgetSema() {
514 if (m_passthrough_sema)
515 m_passthrough_sema->ForgetSema();