ASTResultSynthesizer.cpp revision 341825
1//===-- ASTResultSynthesizer.cpp --------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "ASTResultSynthesizer.h" 11 12#include "ClangPersistentVariables.h" 13 14#include "lldb/Symbol/ClangASTContext.h" 15#include "lldb/Symbol/ClangASTImporter.h" 16#include "lldb/Target/Target.h" 17#include "lldb/Utility/LLDBAssert.h" 18#include "lldb/Utility/Log.h" 19#include "stdlib.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" 31 32using namespace llvm; 33using namespace clang; 34using namespace lldb_private; 35 36ASTResultSynthesizer::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) { 40 if (!m_passthrough) 41 return; 42 43 m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough); 44} 45 46ASTResultSynthesizer::~ASTResultSynthesizer() {} 47 48void ASTResultSynthesizer::Initialize(ASTContext &Context) { 49 m_ast_context = &Context; 50 51 if (m_passthrough) 52 m_passthrough->Initialize(Context); 53} 54 55void ASTResultSynthesizer::TransformTopLevelDecl(Decl *D) { 56 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 57 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()); 66 else 67 log->Printf("TransformTopLevelDecl(<complex>)"); 68 } 69 70 if (m_top_level) { 71 RecordPersistentDecl(named_decl); 72 } 73 } 74 75 if (LinkageSpecDecl *linkage_spec_decl = dyn_cast<LinkageSpecDecl>(D)) { 76 RecordDecl::decl_iterator decl_iterator; 77 78 for (decl_iterator = linkage_spec_decl->decls_begin(); 79 decl_iterator != linkage_spec_decl->decls_end(); ++decl_iterator) { 80 TransformTopLevelDecl(*decl_iterator); 81 } 82 } else if (!m_top_level) { 83 if (ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(D)) { 84 if (m_ast_context && 85 !method_decl->getSelector().getAsString().compare("$__lldb_expr:")) { 86 RecordPersistentTypes(method_decl); 87 SynthesizeObjCMethodResult(method_decl); 88 } 89 } else if (FunctionDecl *function_decl = dyn_cast<FunctionDecl>(D)) { 90 if (m_ast_context && 91 !function_decl->getNameInfo().getAsString().compare("$__lldb_expr")) { 92 RecordPersistentTypes(function_decl); 93 SynthesizeFunctionResult(function_decl); 94 } 95 } 96 } 97} 98 99bool ASTResultSynthesizer::HandleTopLevelDecl(DeclGroupRef D) { 100 DeclGroupRef::iterator decl_iterator; 101 102 for (decl_iterator = D.begin(); decl_iterator != D.end(); ++decl_iterator) { 103 Decl *decl = *decl_iterator; 104 105 TransformTopLevelDecl(decl); 106 } 107 108 if (m_passthrough) 109 return m_passthrough->HandleTopLevelDecl(D); 110 return true; 111} 112 113bool ASTResultSynthesizer::SynthesizeFunctionResult(FunctionDecl *FunDecl) { 114 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 115 116 if (!m_sema) 117 return false; 118 119 FunctionDecl *function_decl = FunDecl; 120 121 if (!function_decl) 122 return false; 123 124 if (log && log->GetVerbose()) { 125 std::string s; 126 raw_string_ostream os(s); 127 128 function_decl->print(os); 129 130 os.flush(); 131 132 log->Printf("Untransformed function AST:\n%s", s.c_str()); 133 } 134 135 Stmt *function_body = function_decl->getBody(); 136 CompoundStmt *compound_stmt = dyn_cast<CompoundStmt>(function_body); 137 138 bool ret = SynthesizeBodyResult(compound_stmt, function_decl); 139 140 if (log && log->GetVerbose()) { 141 std::string s; 142 raw_string_ostream os(s); 143 144 function_decl->print(os); 145 146 os.flush(); 147 148 log->Printf("Transformed function AST:\n%s", s.c_str()); 149 } 150 151 return ret; 152} 153 154bool ASTResultSynthesizer::SynthesizeObjCMethodResult( 155 ObjCMethodDecl *MethodDecl) { 156 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 157 158 if (!m_sema) 159 return false; 160 161 if (!MethodDecl) 162 return false; 163 164 if (log && log->GetVerbose()) { 165 std::string s; 166 raw_string_ostream os(s); 167 168 MethodDecl->print(os); 169 170 os.flush(); 171 172 log->Printf("Untransformed method AST:\n%s", s.c_str()); 173 } 174 175 Stmt *method_body = MethodDecl->getBody(); 176 177 if (!method_body) 178 return false; 179 180 CompoundStmt *compound_stmt = dyn_cast<CompoundStmt>(method_body); 181 182 bool ret = SynthesizeBodyResult(compound_stmt, MethodDecl); 183 184 if (log && log->GetVerbose()) { 185 std::string s; 186 raw_string_ostream os(s); 187 188 MethodDecl->print(os); 189 190 os.flush(); 191 192 log->Printf("Transformed method AST:\n%s", s.c_str()); 193 } 194 195 return ret; 196} 197 198bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body, 199 DeclContext *DC) { 200 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 201 202 ASTContext &Ctx(*m_ast_context); 203 204 if (!Body) 205 return false; 206 207 if (Body->body_empty()) 208 return false; 209 210 Stmt **last_stmt_ptr = Body->body_end() - 1; 211 Stmt *last_stmt = *last_stmt_ptr; 212 213 while (dyn_cast<NullStmt>(last_stmt)) { 214 if (last_stmt_ptr != Body->body_begin()) { 215 last_stmt_ptr--; 216 last_stmt = *last_stmt_ptr; 217 } else { 218 return false; 219 } 220 } 221 222 Expr *last_expr = dyn_cast<Expr>(last_stmt); 223 224 if (!last_expr) 225 // No auxiliary variable necessary; expression returns void 226 return true; 227 228 // In C++11, last_expr can be a LValueToRvalue implicit cast. Strip that off 229 // if that's the case. 230 231 do { 232 ImplicitCastExpr *implicit_cast = dyn_cast<ImplicitCastExpr>(last_expr); 233 234 if (!implicit_cast) 235 break; 236 237 if (implicit_cast->getCastKind() != CK_LValueToRValue) 238 break; 239 240 last_expr = implicit_cast->getSubExpr(); 241 } while (0); 242 243 // is_lvalue is used to record whether the expression returns an assignable 244 // Lvalue or an Rvalue. This is relevant because they are handled 245 // differently. 246 // 247 // For Lvalues 248 // 249 // - In AST result synthesis (here!) the expression E is transformed into an 250 // initialization 251 // T *$__lldb_expr_result_ptr = &E. 252 // 253 // - In structure allocation, a pointer-sized slot is allocated in the 254 // struct that is to be 255 // passed into the expression. 256 // 257 // - In IR transformations, reads and writes to $__lldb_expr_result_ptr are 258 // redirected at 259 // an entry in the struct ($__lldb_arg) passed into the expression. 260 // (Other persistent 261 // variables are treated similarly, having been materialized as 262 // references, but in those 263 // cases the value of the reference itself is never modified.) 264 // 265 // - During materialization, $0 (the result persistent variable) is ignored. 266 // 267 // - During dematerialization, $0 is marked up as a load address with value 268 // equal to the 269 // contents of the structure entry. 270 // 271 // For Rvalues 272 // 273 // - In AST result synthesis the expression E is transformed into an 274 // initialization 275 // static T $__lldb_expr_result = E. 276 // 277 // - In structure allocation, a pointer-sized slot is allocated in the 278 // struct that is to be 279 // passed into the expression. 280 // 281 // - In IR transformations, an instruction is inserted at the beginning of 282 // the function to 283 // dereference the pointer resident in the slot. Reads and writes to 284 // $__lldb_expr_result 285 // are redirected at that dereferenced version. Guard variables for the 286 // static variable 287 // are excised. 288 // 289 // - During materialization, $0 (the result persistent variable) is 290 // populated with the location 291 // of a newly-allocated area of memory. 292 // 293 // - During dematerialization, $0 is ignored. 294 295 bool is_lvalue = last_expr->getValueKind() == VK_LValue && 296 last_expr->getObjectKind() == OK_Ordinary; 297 298 QualType expr_qual_type = last_expr->getType(); 299 const clang::Type *expr_type = expr_qual_type.getTypePtr(); 300 301 if (!expr_type) 302 return false; 303 304 if (expr_type->isVoidType()) 305 return true; 306 307 if (log) { 308 std::string s = expr_qual_type.getAsString(); 309 310 log->Printf("Last statement is an %s with type: %s", 311 (is_lvalue ? "lvalue" : "rvalue"), s.c_str()); 312 } 313 314 clang::VarDecl *result_decl = NULL; 315 316 if (is_lvalue) { 317 IdentifierInfo *result_ptr_id; 318 319 if (expr_type->isFunctionType()) 320 result_ptr_id = 321 &Ctx.Idents.get("$__lldb_expr_result"); // functions actually should 322 // be treated like function 323 // pointers 324 else 325 result_ptr_id = &Ctx.Idents.get("$__lldb_expr_result_ptr"); 326 327 m_sema->RequireCompleteType(SourceLocation(), expr_qual_type, 328 clang::diag::err_incomplete_type); 329 330 QualType ptr_qual_type; 331 332 if (expr_qual_type->getAs<ObjCObjectType>() != NULL) 333 ptr_qual_type = Ctx.getObjCObjectPointerType(expr_qual_type); 334 else 335 ptr_qual_type = Ctx.getPointerType(expr_qual_type); 336 337 result_decl = 338 VarDecl::Create(Ctx, DC, SourceLocation(), SourceLocation(), 339 result_ptr_id, ptr_qual_type, NULL, SC_Static); 340 341 if (!result_decl) 342 return false; 343 344 ExprResult address_of_expr = 345 m_sema->CreateBuiltinUnaryOp(SourceLocation(), UO_AddrOf, last_expr); 346 if (address_of_expr.get()) 347 m_sema->AddInitializerToDecl(result_decl, address_of_expr.get(), true); 348 else 349 return false; 350 } else { 351 IdentifierInfo &result_id = Ctx.Idents.get("$__lldb_expr_result"); 352 353 result_decl = VarDecl::Create(Ctx, DC, SourceLocation(), SourceLocation(), 354 &result_id, expr_qual_type, NULL, SC_Static); 355 356 if (!result_decl) 357 return false; 358 359 m_sema->AddInitializerToDecl(result_decl, last_expr, true); 360 } 361 362 DC->addDecl(result_decl); 363 364 /////////////////////////////// 365 // call AddInitializerToDecl 366 // 367 368 // m_sema->AddInitializerToDecl(result_decl, last_expr); 369 370 ///////////////////////////////// 371 // call ConvertDeclToDeclGroup 372 // 373 374 Sema::DeclGroupPtrTy result_decl_group_ptr; 375 376 result_decl_group_ptr = m_sema->ConvertDeclToDeclGroup(result_decl); 377 378 //////////////////////// 379 // call ActOnDeclStmt 380 // 381 382 StmtResult result_initialization_stmt_result(m_sema->ActOnDeclStmt( 383 result_decl_group_ptr, SourceLocation(), SourceLocation())); 384 385 //////////////////////////////////////////////// 386 // replace the old statement with the new one 387 // 388 389 *last_stmt_ptr = 390 reinterpret_cast<Stmt *>(result_initialization_stmt_result.get()); 391 392 return true; 393} 394 395void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) { 396 if (m_passthrough) 397 m_passthrough->HandleTranslationUnit(Ctx); 398} 399 400void ASTResultSynthesizer::RecordPersistentTypes(DeclContext *FunDeclCtx) { 401 typedef DeclContext::specific_decl_iterator<TypeDecl> TypeDeclIterator; 402 403 for (TypeDeclIterator i = TypeDeclIterator(FunDeclCtx->decls_begin()), 404 e = TypeDeclIterator(FunDeclCtx->decls_end()); 405 i != e; ++i) { 406 MaybeRecordPersistentType(*i); 407 } 408} 409 410void ASTResultSynthesizer::MaybeRecordPersistentType(TypeDecl *D) { 411 if (!D->getIdentifier()) 412 return; 413 414 StringRef name = D->getName(); 415 416 if (name.size() == 0 || name[0] != '$') 417 return; 418 419 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 420 421 ConstString name_cs(name.str().c_str()); 422 423 if (log) 424 log->Printf("Recording persistent type %s\n", name_cs.GetCString()); 425 426 m_decls.push_back(D); 427} 428 429void ASTResultSynthesizer::RecordPersistentDecl(NamedDecl *D) { 430 lldbassert(m_top_level); 431 432 if (!D->getIdentifier()) 433 return; 434 435 StringRef name = D->getName(); 436 437 if (name.size() == 0) 438 return; 439 440 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 441 442 ConstString name_cs(name.str().c_str()); 443 444 if (log) 445 log->Printf("Recording persistent decl %s\n", name_cs.GetCString()); 446 447 m_decls.push_back(D); 448} 449 450void ASTResultSynthesizer::CommitPersistentDecls() { 451 for (clang::NamedDecl *decl : m_decls) { 452 StringRef name = decl->getName(); 453 ConstString name_cs(name.str().c_str()); 454 455 Decl *D_scratch = m_target.GetClangASTImporter()->DeportDecl( 456 m_target.GetScratchClangASTContext()->getASTContext(), m_ast_context, 457 decl); 458 459 if (!D_scratch) { 460 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 461 462 if (log) { 463 std::string s; 464 llvm::raw_string_ostream ss(s); 465 decl->dump(ss); 466 ss.flush(); 467 468 log->Printf("Couldn't commit persistent decl: %s\n", s.c_str()); 469 } 470 471 continue; 472 } 473 474 if (NamedDecl *NamedDecl_scratch = dyn_cast<NamedDecl>(D_scratch)) 475 llvm::cast<ClangPersistentVariables>( 476 m_target.GetPersistentExpressionStateForLanguage( 477 lldb::eLanguageTypeC)) 478 ->RegisterPersistentDecl(name_cs, NamedDecl_scratch); 479 } 480} 481 482void ASTResultSynthesizer::HandleTagDeclDefinition(TagDecl *D) { 483 if (m_passthrough) 484 m_passthrough->HandleTagDeclDefinition(D); 485} 486 487void ASTResultSynthesizer::CompleteTentativeDefinition(VarDecl *D) { 488 if (m_passthrough) 489 m_passthrough->CompleteTentativeDefinition(D); 490} 491 492void ASTResultSynthesizer::HandleVTable(CXXRecordDecl *RD) { 493 if (m_passthrough) 494 m_passthrough->HandleVTable(RD); 495} 496 497void ASTResultSynthesizer::PrintStats() { 498 if (m_passthrough) 499 m_passthrough->PrintStats(); 500} 501 502void ASTResultSynthesizer::InitializeSema(Sema &S) { 503 m_sema = &S; 504 505 if (m_passthrough_sema) 506 m_passthrough_sema->InitializeSema(S); 507} 508 509void ASTResultSynthesizer::ForgetSema() { 510 m_sema = NULL; 511 512 if (m_passthrough_sema) 513 m_passthrough_sema->ForgetSema(); 514} 515