ASTResultSynthesizer.cpp revision 360784
1//===-- ASTResultSynthesizer.cpp --------------------------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include "ASTResultSynthesizer.h" 10 11#include "ClangPersistentVariables.h" 12 13#include "lldb/Symbol/ClangASTContext.h" 14#include "lldb/Symbol/ClangASTImporter.h" 15#include "lldb/Target/Target.h" 16#include "lldb/Utility/LLDBAssert.h" 17#include "lldb/Utility/Log.h" 18#include "stdlib.h" 19#include "clang/AST/ASTContext.h" 20#include "clang/AST/Decl.h" 21#include "clang/AST/DeclCXX.h" 22#include "clang/AST/DeclGroup.h" 23#include "clang/AST/DeclObjC.h" 24#include "clang/AST/Expr.h" 25#include "clang/AST/Stmt.h" 26#include "clang/Parse/Parser.h" 27#include "clang/Sema/SemaDiagnostic.h" 28#include "llvm/Support/Casting.h" 29#include "llvm/Support/raw_ostream.h" 30 31using namespace llvm; 32using namespace clang; 33using namespace lldb_private; 34 35ASTResultSynthesizer::ASTResultSynthesizer(ASTConsumer *passthrough, 36 bool top_level, Target &target) 37 : m_ast_context(nullptr), m_passthrough(passthrough), 38 m_passthrough_sema(nullptr), m_target(target), m_sema(nullptr), 39 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 LLDB_LOGF(log, "TransformTopLevelDecl(%s)", 62 named_decl->getIdentifier()->getNameStart()); 63 else if (ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(D)) 64 LLDB_LOGF(log, "TransformTopLevelDecl(%s)", 65 method_decl->getSelector().getAsString().c_str()); 66 else 67 LLDB_LOGF(log, "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 LLDB_LOGF(log, "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 LLDB_LOGF(log, "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 LLDB_LOGF(log, "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 LLDB_LOGF(log, "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 (false); 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 LLDB_LOGF(log, "Last statement is an %s with type: %s", 312 (is_lvalue ? "lvalue" : "rvalue"), s.c_str()); 313 } 314 315 clang::VarDecl *result_decl = nullptr; 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>() != nullptr) 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, nullptr, 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 = 355 VarDecl::Create(Ctx, DC, SourceLocation(), SourceLocation(), &result_id, 356 expr_qual_type, nullptr, SC_Static); 357 358 if (!result_decl) 359 return false; 360 361 m_sema->AddInitializerToDecl(result_decl, last_expr, true); 362 } 363 364 DC->addDecl(result_decl); 365 366 /////////////////////////////// 367 // call AddInitializerToDecl 368 // 369 370 // m_sema->AddInitializerToDecl(result_decl, last_expr); 371 372 ///////////////////////////////// 373 // call ConvertDeclToDeclGroup 374 // 375 376 Sema::DeclGroupPtrTy result_decl_group_ptr; 377 378 result_decl_group_ptr = m_sema->ConvertDeclToDeclGroup(result_decl); 379 380 //////////////////////// 381 // call ActOnDeclStmt 382 // 383 384 StmtResult result_initialization_stmt_result(m_sema->ActOnDeclStmt( 385 result_decl_group_ptr, SourceLocation(), SourceLocation())); 386 387 //////////////////////////////////////////////// 388 // replace the old statement with the new one 389 // 390 391 *last_stmt_ptr = static_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 LLDB_LOGF(log, "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 LLDB_LOGF(log, "Recording persistent decl %s\n", name_cs.GetCString()); 445 446 m_decls.push_back(D); 447} 448 449void ASTResultSynthesizer::CommitPersistentDecls() { 450 auto *state = 451 m_target.GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC); 452 if (!state) 453 return; 454 455 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state); 456 ClangASTContext *scratch_ctx = ClangASTContext::GetScratch(m_target); 457 458 for (clang::NamedDecl *decl : m_decls) { 459 StringRef name = decl->getName(); 460 ConstString name_cs(name.str().c_str()); 461 462 Decl *D_scratch = m_target.GetClangASTImporter()->DeportDecl( 463 &scratch_ctx->getASTContext(), decl); 464 465 if (!D_scratch) { 466 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 467 468 if (log) { 469 std::string s; 470 llvm::raw_string_ostream ss(s); 471 decl->dump(ss); 472 ss.flush(); 473 474 LLDB_LOGF(log, "Couldn't commit persistent decl: %s\n", s.c_str()); 475 } 476 477 continue; 478 } 479 480 if (NamedDecl *NamedDecl_scratch = dyn_cast<NamedDecl>(D_scratch)) 481 persistent_vars->RegisterPersistentDecl(name_cs, NamedDecl_scratch, 482 scratch_ctx); 483 } 484} 485 486void ASTResultSynthesizer::HandleTagDeclDefinition(TagDecl *D) { 487 if (m_passthrough) 488 m_passthrough->HandleTagDeclDefinition(D); 489} 490 491void ASTResultSynthesizer::CompleteTentativeDefinition(VarDecl *D) { 492 if (m_passthrough) 493 m_passthrough->CompleteTentativeDefinition(D); 494} 495 496void ASTResultSynthesizer::HandleVTable(CXXRecordDecl *RD) { 497 if (m_passthrough) 498 m_passthrough->HandleVTable(RD); 499} 500 501void ASTResultSynthesizer::PrintStats() { 502 if (m_passthrough) 503 m_passthrough->PrintStats(); 504} 505 506void ASTResultSynthesizer::InitializeSema(Sema &S) { 507 m_sema = &S; 508 509 if (m_passthrough_sema) 510 m_passthrough_sema->InitializeSema(S); 511} 512 513void ASTResultSynthesizer::ForgetSema() { 514 m_sema = nullptr; 515 516 if (m_passthrough_sema) 517 m_passthrough_sema->ForgetSema(); 518} 519