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
32 using namespace llvm;
33 using namespace clang;
34 using namespace lldb_private;
35
ASTResultSynthesizer(ASTConsumer * passthrough,bool top_level,Target & target)36 ASTResultSynthesizer::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
~ASTResultSynthesizer()46 ASTResultSynthesizer::~ASTResultSynthesizer() {}
47
Initialize(ASTContext & Context)48 void ASTResultSynthesizer::Initialize(ASTContext &Context) {
49 m_ast_context = &Context;
50
51 if (m_passthrough)
52 m_passthrough->Initialize(Context);
53 }
54
TransformTopLevelDecl(Decl * D)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
HandleTopLevelDecl(DeclGroupRef D)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
SynthesizeFunctionResult(FunctionDecl * FunDecl)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
SynthesizeObjCMethodResult(ObjCMethodDecl * MethodDecl)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
SynthesizeBodyResult(CompoundStmt * Body,DeclContext * DC)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 (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
HandleTranslationUnit(ASTContext & Ctx)396 void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) {
397 if (m_passthrough)
398 m_passthrough->HandleTranslationUnit(Ctx);
399 }
400
RecordPersistentTypes(DeclContext * FunDeclCtx)401 void 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
MaybeRecordPersistentType(TypeDecl * D)411 void 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
RecordPersistentDecl(NamedDecl * D)430 void 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
CommitPersistentDecls()451 void 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
HandleTagDeclDefinition(TagDecl * D)483 void ASTResultSynthesizer::HandleTagDeclDefinition(TagDecl *D) {
484 if (m_passthrough)
485 m_passthrough->HandleTagDeclDefinition(D);
486 }
487
CompleteTentativeDefinition(VarDecl * D)488 void ASTResultSynthesizer::CompleteTentativeDefinition(VarDecl *D) {
489 if (m_passthrough)
490 m_passthrough->CompleteTentativeDefinition(D);
491 }
492
HandleVTable(CXXRecordDecl * RD)493 void ASTResultSynthesizer::HandleVTable(CXXRecordDecl *RD) {
494 if (m_passthrough)
495 m_passthrough->HandleVTable(RD);
496 }
497
PrintStats()498 void ASTResultSynthesizer::PrintStats() {
499 if (m_passthrough)
500 m_passthrough->PrintStats();
501 }
502
InitializeSema(Sema & S)503 void ASTResultSynthesizer::InitializeSema(Sema &S) {
504 m_sema = &S;
505
506 if (m_passthrough_sema)
507 m_passthrough_sema->InitializeSema(S);
508 }
509
ForgetSema()510 void ASTResultSynthesizer::ForgetSema() {
511 m_sema = NULL;
512
513 if (m_passthrough_sema)
514 m_passthrough_sema->ForgetSema();
515 }
516