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