ASTResultSynthesizer.cpp

Go to the documentation of this file.

//===-- ASTResultSynthesizer.cpp ------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "ASTResultSynthesizer.h"
 
#include "ClangASTImporter.h"
#include "ClangPersistentVariables.h"
 
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclGroup.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/Expr.h"
#include "clang/AST/Stmt.h"
#include "clang/Parse/Parser.h"
#include "clang/Sema/SemaDiagnostic.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/raw_ostream.h"
#include <cstdlib>
 
using namespace llvm;
using namespace clang;
using namespace lldb_private;
 
ASTResultSynthesizer::ASTResultSynthesizer(ASTConsumer *passthrough,
                                           bool top_level, Target &target)
    : m_ast_context(nullptr), m_passthrough(passthrough),
      m_passthrough_sema(nullptr), m_target(target), m_sema(nullptr),
      m_top_level(top_level) {
  if (!m_passthrough)
    return;
 
  m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough);
}
 
ASTResultSynthesizer::~ASTResultSynthesizer() = default;
 
void ASTResultSynthesizer::Initialize(ASTContext &Context) {
  m_ast_context = &Context;
 
  if (m_passthrough)
    m_passthrough->Initialize(Context);
}
 
void ASTResultSynthesizer::TransformTopLevelDecl(Decl *D) {
  Log *log = GetLog(LLDBLog::Expressions);
 
  if (NamedDecl *named_decl = dyn_cast<NamedDecl>(D)) {
    if (log && log->GetVerbose()) {
      if (named_decl->getIdentifier())
        LLDB_LOGF(log, "TransformTopLevelDecl(%s)",
                  named_decl->getIdentifier()->getNameStart());
      else if (ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(D))
        LLDB_LOGF(log, "TransformTopLevelDecl(%s)",
                  method_decl->getSelector().getAsString().c_str());
      else
        LLDB_LOGF(log, "TransformTopLevelDecl(<complex>)");
    }
 
    if (m_top_level) {
      RecordPersistentDecl(named_decl);
    }
  }
 
  if (LinkageSpecDecl *linkage_spec_decl = dyn_cast<LinkageSpecDecl>(D)) {
    RecordDecl::decl_iterator decl_iterator;
 
    for (decl_iterator = linkage_spec_decl->decls_begin();
         decl_iterator != linkage_spec_decl->decls_end(); ++decl_iterator) {
      TransformTopLevelDecl(*decl_iterator);
    }
  } else if (!m_top_level) {
    if (ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(D)) {
      if (m_ast_context &&
          !method_decl->getSelector().getAsString().compare("$__lldb_expr:")) {
        RecordPersistentTypes(method_decl);
        SynthesizeObjCMethodResult(method_decl);
      }
    } else if (FunctionDecl *function_decl = dyn_cast<FunctionDecl>(D)) {
      // When completing user input the body of the function may be a nullptr.
      if (m_ast_context && function_decl->hasBody() &&
          !function_decl->getNameInfo().getAsString().compare("$__lldb_expr")) {
        RecordPersistentTypes(function_decl);
        SynthesizeFunctionResult(function_decl);
      }
    }
  }
}
 
bool ASTResultSynthesizer::HandleTopLevelDecl(DeclGroupRef D) {
  DeclGroupRef::iterator decl_iterator;
 
  for (decl_iterator = D.begin(); decl_iterator != D.end(); ++decl_iterator) {
    Decl *decl = *decl_iterator;
 
    TransformTopLevelDecl(decl);
  }
 
  if (m_passthrough)
    return m_passthrough->HandleTopLevelDecl(D);
  return true;
}
 
bool ASTResultSynthesizer::SynthesizeFunctionResult(FunctionDecl *FunDecl) {
  Log *log = GetLog(LLDBLog::Expressions);
 
  if (!m_sema)
    return false;
 
  FunctionDecl *function_decl = FunDecl;
 
  if (!function_decl)
    return false;
 
  if (log && log->GetVerbose()) {
    std::string s;
    raw_string_ostream os(s);
 
    function_decl->print(os);
 
    LLDB_LOGF(log, "Untransformed function AST:\n%s", s.c_str());
  }
 
  Stmt *function_body = function_decl->getBody();
  CompoundStmt *compound_stmt = dyn_cast<CompoundStmt>(function_body);
 
  bool ret = SynthesizeBodyResult(compound_stmt, function_decl);
 
  if (log && log->GetVerbose()) {
    std::string s;
    raw_string_ostream os(s);
 
    function_decl->print(os);
 
    LLDB_LOGF(log, "Transformed function AST:\n%s", s.c_str());
  }
 
  return ret;
}
 
bool ASTResultSynthesizer::SynthesizeObjCMethodResult(
    ObjCMethodDecl *MethodDecl) {
  Log *log = GetLog(LLDBLog::Expressions);
 
  if (!m_sema)
    return false;
 
  if (!MethodDecl)
    return false;
 
  if (log && log->GetVerbose()) {
    std::string s;
    raw_string_ostream os(s);
 
    MethodDecl->print(os);
 
    LLDB_LOGF(log, "Untransformed method AST:\n%s", s.c_str());
  }
 
  Stmt *method_body = MethodDecl->getBody();
 
  if (!method_body)
    return false;
 
  CompoundStmt *compound_stmt = dyn_cast<CompoundStmt>(method_body);
 
  bool ret = SynthesizeBodyResult(compound_stmt, MethodDecl);
 
  if (log && log->GetVerbose()) {
    std::string s;
    raw_string_ostream os(s);
 
    MethodDecl->print(os);
 
    LLDB_LOGF(log, "Transformed method AST:\n%s", s.c_str());
  }
 
  return ret;
}
 
/// Returns true if LLDB can take the address of the given lvalue for the sake
/// of capturing the expression result. Returns false if LLDB should instead
/// store the expression result in a result variable.
static bool CanTakeAddressOfLValue(const Expr *lvalue_expr) {
  assert(lvalue_expr->getValueKind() == VK_LValue &&
         "lvalue_expr not a lvalue");
 
  QualType qt = lvalue_expr->getType();
  // If the lvalue has const-qualified non-volatile integral or enum type, then
  // the underlying value might come from a const static data member as
  // described in C++11 [class.static.data]p3. If that's the case, then the
  // value might not have an address if the user didn't also define the member
  // in a namespace scope. Taking the address would cause that LLDB later fails
  // to link the expression, so those lvalues should be stored in a result
  // variable.
  if (qt->isIntegralOrEnumerationType() && qt.isConstQualified() &&
      !qt.isVolatileQualified())
    return false;
  return true;
}
 
bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
                                                DeclContext *DC) {
  Log *log = GetLog(LLDBLog::Expressions);
 
  ASTContext &Ctx(*m_ast_context);
 
  if (!Body)
    return false;
 
  if (Body->body_empty())
    return false;
 
  Stmt **last_stmt_ptr = Body->body_end() - 1;
  Stmt *last_stmt = *last_stmt_ptr;
 
  while (isa<NullStmt>(last_stmt)) {
    if (last_stmt_ptr != Body->body_begin()) {
      last_stmt_ptr--;
      last_stmt = *last_stmt_ptr;
    } else {
      return false;
    }
  }
 
  Expr *last_expr = dyn_cast<Expr>(last_stmt);
 
  if (!last_expr)
    // No auxiliary variable necessary; expression returns void
    return true;
 
  // In C++11, last_expr can be a LValueToRvalue implicit cast.  Strip that off
  // if that's the case.
 
  do {
    ImplicitCastExpr *implicit_cast = dyn_cast<ImplicitCastExpr>(last_expr);
 
    if (!implicit_cast)
      break;
 
    if (implicit_cast->getCastKind() != CK_LValueToRValue)
      break;
 
    last_expr = implicit_cast->getSubExpr();
  } while (false);
 
  // is_lvalue is used to record whether the expression returns an assignable
  // Lvalue or an Rvalue.  This is relevant because they are handled
  // differently.
  //
  // For Lvalues
  //
  //   - In AST result synthesis (here!) the expression E is transformed into an
  //     initialization T *$__lldb_expr_result_ptr = &E.
  //
  //   - In structure allocation, a pointer-sized slot is allocated in the
  //     struct that is to be passed into the expression.
  //
  //   - In IR transformations, reads and writes to $__lldb_expr_result_ptr are
  //     redirected at an entry in the struct ($__lldb_arg) passed into the
  //     expression. (Other persistent variables are treated similarly, having
  //     been materialized as references, but in those cases the value of the
  //     reference itself is never modified.)
  //
  //   - During materialization, $0 (the result persistent variable) is ignored.
  //
  //   - During dematerialization, $0 is marked up as a load address with value
  //     equal to the contents of the structure entry.
  //
  //   - Note: if we cannot take an address of the resulting Lvalue (e.g. it's
  //     a static const member without an out-of-class definition), then we
  //     follow the Rvalue route.
  //
  // For Rvalues
  //
  //   - In AST result synthesis the expression E is transformed into an
  //     initialization static T $__lldb_expr_result = E.
  //
  //   - In structure allocation, a pointer-sized slot is allocated in the
  //     struct that is to be passed into the expression.
  //
  //   - In IR transformations, an instruction is inserted at the beginning of
  //     the function to dereference the pointer resident in the slot. Reads and
  //     writes to $__lldb_expr_result are redirected at that dereferenced
  //     version. Guard variables for the static variable are excised.
  //
  //   - During materialization, $0 (the result persistent variable) is
  //     populated with the location of a newly-allocated area of memory.
  //
  //   - During dematerialization, $0 is ignored.
 
  bool is_lvalue = last_expr->getValueKind() == VK_LValue &&
                   last_expr->getObjectKind() == OK_Ordinary;
 
  QualType expr_qual_type = last_expr->getType();
  const clang::Type *expr_type = expr_qual_type.getTypePtr();
 
  if (!expr_type)
    return false;
 
  if (expr_type->isVoidType())
    return true;
 
  if (log) {
    std::string s = expr_qual_type.getAsString();
 
    LLDB_LOGF(log, "Last statement is an %s with type: %s",
              (is_lvalue ? "lvalue" : "rvalue"), s.c_str());
  }
 
  clang::VarDecl *result_decl = nullptr;
 
  if (is_lvalue && CanTakeAddressOfLValue(last_expr)) {
    IdentifierInfo *result_ptr_id;
 
    if (expr_type->isFunctionType())
      result_ptr_id =
          &Ctx.Idents.get("$__lldb_expr_result"); // functions actually should
                                                  // be treated like function
                                                  // pointers
    else
      result_ptr_id = &Ctx.Idents.get("$__lldb_expr_result_ptr");
 
    m_sema->RequireCompleteType(last_expr->getSourceRange().getBegin(),
                                expr_qual_type,
                                clang::diag::err_incomplete_type);
 
    QualType ptr_qual_type;
 
    if (expr_qual_type->getAs<ObjCObjectType>() != nullptr)
      ptr_qual_type = Ctx.getObjCObjectPointerType(expr_qual_type);
    else
      ptr_qual_type = Ctx.getPointerType(expr_qual_type);
 
    result_decl =
        VarDecl::Create(Ctx, DC, SourceLocation(), SourceLocation(),
                        result_ptr_id, ptr_qual_type, nullptr, SC_Static);
 
    if (!result_decl)
      return false;
 
    ExprResult address_of_expr =
        m_sema->CreateBuiltinUnaryOp(SourceLocation(), UO_AddrOf, last_expr);
    if (address_of_expr.get())
      m_sema->AddInitializerToDecl(result_decl, address_of_expr.get(), true);
    else
      return false;
  } else {
    IdentifierInfo &result_id = Ctx.Idents.get("$__lldb_expr_result");
 
    result_decl =
        VarDecl::Create(Ctx, DC, SourceLocation(), SourceLocation(), &result_id,
                        expr_qual_type, nullptr, SC_Static);
 
    if (!result_decl)
      return false;
 
    m_sema->AddInitializerToDecl(result_decl, last_expr, true);
  }
 
  DC->addDecl(result_decl);
 
  ///////////////////////////////
  // call AddInitializerToDecl
  //
 
  // m_sema->AddInitializerToDecl(result_decl, last_expr);
 
  /////////////////////////////////
  // call ConvertDeclToDeclGroup
  //
 
  Sema::DeclGroupPtrTy result_decl_group_ptr;
 
  result_decl_group_ptr = m_sema->ConvertDeclToDeclGroup(result_decl);
 
  ////////////////////////
  // call ActOnDeclStmt
  //
 
  StmtResult result_initialization_stmt_result(m_sema->ActOnDeclStmt(
      result_decl_group_ptr, SourceLocation(), SourceLocation()));
 
  ////////////////////////////////////////////////
  // replace the old statement with the new one
  //
 
  *last_stmt_ptr = static_cast<Stmt *>(result_initialization_stmt_result.get());
 
  return true;
}
 
void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) {
  if (m_passthrough)
    m_passthrough->HandleTranslationUnit(Ctx);
}
 
void ASTResultSynthesizer::RecordPersistentTypes(DeclContext *FunDeclCtx) {
  typedef DeclContext::specific_decl_iterator<TypeDecl> TypeDeclIterator;
 
  for (TypeDeclIterator i = TypeDeclIterator(FunDeclCtx->decls_begin()),
                        e = TypeDeclIterator(FunDeclCtx->decls_end());
       i != e; ++i) {
    MaybeRecordPersistentType(*i);
  }
}
 
void ASTResultSynthesizer::MaybeRecordPersistentType(TypeDecl *D) {
  if (!D->getIdentifier())
    return;
 
  StringRef name = D->getName();
  if (name.empty() || name.front() != '$')
    return;
 
  LLDB_LOG(GetLog(LLDBLog::Expressions), "Recording persistent type {0}", name);
 
  m_decls.push_back(D);
}
 
void ASTResultSynthesizer::RecordPersistentDecl(NamedDecl *D) {
  lldbassert(m_top_level);
 
  if (!D->getIdentifier())
    return;
 
  StringRef name = D->getName();
  if (name.empty())
    return;
 
  LLDB_LOG(GetLog(LLDBLog::Expressions), "Recording persistent decl {0}", name);
 
  m_decls.push_back(D);
}
 
void ASTResultSynthesizer::CommitPersistentDecls() {
  auto *state =
      m_target.GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC);
  if (!state)
    return;
 
  auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
 
  lldb::TypeSystemClangSP scratch_ts_sp = ScratchTypeSystemClang::GetForTarget(
      m_target, m_ast_context->getLangOpts());
 
  for (clang::NamedDecl *decl : m_decls) {
    StringRef name = decl->getName();
 
    Decl *D_scratch = persistent_vars->GetClangASTImporter()->DeportDecl(
        &scratch_ts_sp->getASTContext(), decl);
 
    if (!D_scratch) {
      Log *log = GetLog(LLDBLog::Expressions);
 
      if (log) {
        std::string s;
        llvm::raw_string_ostream ss(s);
        decl->dump(ss);
 
        LLDB_LOGF(log, "Couldn't commit persistent  decl: %s\n", s.c_str());
      }
 
      continue;
    }
 
    if (NamedDecl *NamedDecl_scratch = dyn_cast<NamedDecl>(D_scratch))
      persistent_vars->RegisterPersistentDecl(ConstString(name),
                                              NamedDecl_scratch, scratch_ts_sp);
  }
}
 
void ASTResultSynthesizer::HandleTagDeclDefinition(TagDecl *D) {
  if (m_passthrough)
    m_passthrough->HandleTagDeclDefinition(D);
}
 
void ASTResultSynthesizer::CompleteTentativeDefinition(VarDecl *D) {
  if (m_passthrough)
    m_passthrough->CompleteTentativeDefinition(D);
}
 
void ASTResultSynthesizer::HandleVTable(CXXRecordDecl *RD) {
  if (m_passthrough)
    m_passthrough->HandleVTable(RD);
}
 
void ASTResultSynthesizer::PrintStats() {
  if (m_passthrough)
    m_passthrough->PrintStats();
}
 
void ASTResultSynthesizer::InitializeSema(Sema &S) {
  m_sema = &S;
 
  if (m_passthrough_sema)
    m_passthrough_sema->InitializeSema(S);
}
 
void ASTResultSynthesizer::ForgetSema() {
  m_sema = nullptr;
 
  if (m_passthrough_sema)
    m_passthrough_sema->ForgetSema();
}