contrib/llvm-project/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

   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
  31 using namespace llvm;
  32 using namespace clang;
  33 using namespace lldb_private;
  34
  35 ASTResultSynthesizer::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
  46 ASTResultSynthesizer::~ASTResultSynthesizer() {}
  47
  48 void ASTResultSynthesizer::Initialize(ASTContext &Context) {
  49   m_ast_context = &Context;
  50
  51   if (m_passthrough)
  52     m_passthrough->Initialize(Context);
  53 }
  54
  55 void 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
 100 bool 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
 114 bool 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
 155 bool 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
 199 bool 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     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 = 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 =
 392       reinterpret_cast<Stmt *>(result_initialization_stmt_result.get());
 393
 394   return true;
 395 }
 396
 397 void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) {
 398   if (m_passthrough)
 399     m_passthrough->HandleTranslationUnit(Ctx);
 400 }
 401
 402 void ASTResultSynthesizer::RecordPersistentTypes(DeclContext *FunDeclCtx) {
 403   typedef DeclContext::specific_decl_iterator<TypeDecl> TypeDeclIterator;
 404
 405   for (TypeDeclIterator i = TypeDeclIterator(FunDeclCtx->decls_begin()),
 406                         e = TypeDeclIterator(FunDeclCtx->decls_end());
 407        i != e; ++i) {
 408     MaybeRecordPersistentType(*i);
 409   }
 410 }
 411
 412 void ASTResultSynthesizer::MaybeRecordPersistentType(TypeDecl *D) {
 413   if (!D->getIdentifier())
 414     return;
 415
 416   StringRef name = D->getName();
 417
 418   if (name.size() == 0 || name[0] != '$')
 419     return;
 420
 421   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 422
 423   ConstString name_cs(name.str().c_str());
 424
 425   if (log)
 426     log->Printf("Recording persistent type %s\n", name_cs.GetCString());
 427
 428   m_decls.push_back(D);
 429 }
 430
 431 void ASTResultSynthesizer::RecordPersistentDecl(NamedDecl *D) {
 432   lldbassert(m_top_level);
 433
 434   if (!D->getIdentifier())
 435     return;
 436
 437   StringRef name = D->getName();
 438
 439   if (name.size() == 0)
 440     return;
 441
 442   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 443
 444   ConstString name_cs(name.str().c_str());
 445
 446   if (log)
 447     log->Printf("Recording persistent decl %s\n", name_cs.GetCString());
 448
 449   m_decls.push_back(D);
 450 }
 451
 452 void ASTResultSynthesizer::CommitPersistentDecls() {
 453   for (clang::NamedDecl *decl : m_decls) {
 454     StringRef name = decl->getName();
 455     ConstString name_cs(name.str().c_str());
 456
 457     Decl *D_scratch = m_target.GetClangASTImporter()->DeportDecl(
 458         m_target.GetScratchClangASTContext()->getASTContext(), m_ast_context,
 459         decl);
 460
 461     if (!D_scratch) {
 462       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 463
 464       if (log) {
 465         std::string s;
 466         llvm::raw_string_ostream ss(s);
 467         decl->dump(ss);
 468         ss.flush();
 469
 470         log->Printf("Couldn't commit persistent  decl: %s\n", s.c_str());
 471       }
 472
 473       continue;
 474     }
 475
 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);
 481   }
 482 }
 483
 484 void ASTResultSynthesizer::HandleTagDeclDefinition(TagDecl *D) {
 485   if (m_passthrough)
 486     m_passthrough->HandleTagDeclDefinition(D);
 487 }
 488
 489 void ASTResultSynthesizer::CompleteTentativeDefinition(VarDecl *D) {
 490   if (m_passthrough)
 491     m_passthrough->CompleteTentativeDefinition(D);
 492 }
 493
 494 void ASTResultSynthesizer::HandleVTable(CXXRecordDecl *RD) {
 495   if (m_passthrough)
 496     m_passthrough->HandleVTable(RD);
 497 }
 498
 499 void ASTResultSynthesizer::PrintStats() {
 500   if (m_passthrough)
 501     m_passthrough->PrintStats();
 502 }
 503
 504 void ASTResultSynthesizer::InitializeSema(Sema &S) {
 505   m_sema = &S;
 506
 507   if (m_passthrough_sema)
 508     m_passthrough_sema->InitializeSema(S);
 509 }
 510
 511 void ASTResultSynthesizer::ForgetSema() {
 512   m_sema = nullptr;
 513
 514   if (m_passthrough_sema)
 515     m_passthrough_sema->ForgetSema();
 516 }