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