1//=- LiveVariables.cpp - Live Variable Analysis for Source CFGs ----------*-==//
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// This file implements Live Variables analysis for source-level CFGs.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Analysis/Analyses/LiveVariables.h"
15#include "clang/AST/Stmt.h"
16#include "clang/AST/StmtVisitor.h"
17#include "clang/Analysis/Analyses/PostOrderCFGView.h"
18#include "clang/Analysis/AnalysisContext.h"
19#include "clang/Analysis/CFG.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/PostOrderIterator.h"
22#include "llvm/Support/raw_ostream.h"
23#include <algorithm>
24#include <vector>
25
26using namespace clang;
27
28namespace {
29
30class DataflowWorklist {
31  SmallVector<const CFGBlock *, 20> worklist;
32  llvm::BitVector enqueuedBlocks;
33  PostOrderCFGView *POV;
34public:
35  DataflowWorklist(const CFG &cfg, AnalysisDeclContext &Ctx)
36    : enqueuedBlocks(cfg.getNumBlockIDs()),
37      POV(Ctx.getAnalysis<PostOrderCFGView>()) {}
38
39  void enqueueBlock(const CFGBlock *block);
40  void enqueuePredecessors(const CFGBlock *block);
41
42  const CFGBlock *dequeue();
43
44  void sortWorklist();
45};
46
47}
48
49void DataflowWorklist::enqueueBlock(const clang::CFGBlock *block) {
50  if (block && !enqueuedBlocks[block->getBlockID()]) {
51    enqueuedBlocks[block->getBlockID()] = true;
52    worklist.push_back(block);
53  }
54}
55
56void DataflowWorklist::enqueuePredecessors(const clang::CFGBlock *block) {
57  const unsigned OldWorklistSize = worklist.size();
58  for (CFGBlock::const_pred_iterator I = block->pred_begin(),
59       E = block->pred_end(); I != E; ++I) {
60    enqueueBlock(*I);
61  }
62
63  if (OldWorklistSize == 0 || OldWorklistSize == worklist.size())
64    return;
65
66  sortWorklist();
67}
68
69void DataflowWorklist::sortWorklist() {
70  std::sort(worklist.begin(), worklist.end(), POV->getComparator());
71}
72
73const CFGBlock *DataflowWorklist::dequeue() {
74  if (worklist.empty())
75    return nullptr;
76  const CFGBlock *b = worklist.pop_back_val();
77  enqueuedBlocks[b->getBlockID()] = false;
78  return b;
79}
80
81namespace {
82class LiveVariablesImpl {
83public:
84  AnalysisDeclContext &analysisContext;
85  std::vector<LiveVariables::LivenessValues> cfgBlockValues;
86  llvm::ImmutableSet<const Stmt *>::Factory SSetFact;
87  llvm::ImmutableSet<const VarDecl *>::Factory DSetFact;
88  llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksEndToLiveness;
89  llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksBeginToLiveness;
90  llvm::DenseMap<const Stmt *, LiveVariables::LivenessValues> stmtsToLiveness;
91  llvm::DenseMap<const DeclRefExpr *, unsigned> inAssignment;
92  const bool killAtAssign;
93
94  LiveVariables::LivenessValues
95  merge(LiveVariables::LivenessValues valsA,
96        LiveVariables::LivenessValues valsB);
97
98  LiveVariables::LivenessValues
99  runOnBlock(const CFGBlock *block, LiveVariables::LivenessValues val,
100             LiveVariables::Observer *obs = nullptr);
101
102  void dumpBlockLiveness(const SourceManager& M);
103
104  LiveVariablesImpl(AnalysisDeclContext &ac, bool KillAtAssign)
105    : analysisContext(ac),
106      SSetFact(false), // Do not canonicalize ImmutableSets by default.
107      DSetFact(false), // This is a *major* performance win.
108      killAtAssign(KillAtAssign) {}
109};
110}
111
112static LiveVariablesImpl &getImpl(void *x) {
113  return *((LiveVariablesImpl *) x);
114}
115
116//===----------------------------------------------------------------------===//
117// Operations and queries on LivenessValues.
118//===----------------------------------------------------------------------===//
119
120bool LiveVariables::LivenessValues::isLive(const Stmt *S) const {
121  return liveStmts.contains(S);
122}
123
124bool LiveVariables::LivenessValues::isLive(const VarDecl *D) const {
125  return liveDecls.contains(D);
126}
127
128namespace {
129  template <typename SET>
130  SET mergeSets(SET A, SET B) {
131    if (A.isEmpty())
132      return B;
133
134    for (typename SET::iterator it = B.begin(), ei = B.end(); it != ei; ++it) {
135      A = A.add(*it);
136    }
137    return A;
138  }
139}
140
141void LiveVariables::Observer::anchor() { }
142
143LiveVariables::LivenessValues
144LiveVariablesImpl::merge(LiveVariables::LivenessValues valsA,
145                         LiveVariables::LivenessValues valsB) {
146
147  llvm::ImmutableSetRef<const Stmt *>
148    SSetRefA(valsA.liveStmts.getRootWithoutRetain(), SSetFact.getTreeFactory()),
149    SSetRefB(valsB.liveStmts.getRootWithoutRetain(), SSetFact.getTreeFactory());
150
151
152  llvm::ImmutableSetRef<const VarDecl *>
153    DSetRefA(valsA.liveDecls.getRootWithoutRetain(), DSetFact.getTreeFactory()),
154    DSetRefB(valsB.liveDecls.getRootWithoutRetain(), DSetFact.getTreeFactory());
155
156
157  SSetRefA = mergeSets(SSetRefA, SSetRefB);
158  DSetRefA = mergeSets(DSetRefA, DSetRefB);
159
160  // asImmutableSet() canonicalizes the tree, allowing us to do an easy
161  // comparison afterwards.
162  return LiveVariables::LivenessValues(SSetRefA.asImmutableSet(),
163                                       DSetRefA.asImmutableSet());
164}
165
166bool LiveVariables::LivenessValues::equals(const LivenessValues &V) const {
167  return liveStmts == V.liveStmts && liveDecls == V.liveDecls;
168}
169
170//===----------------------------------------------------------------------===//
171// Query methods.
172//===----------------------------------------------------------------------===//
173
174static bool isAlwaysAlive(const VarDecl *D) {
175  return D->hasGlobalStorage();
176}
177
178bool LiveVariables::isLive(const CFGBlock *B, const VarDecl *D) {
179  return isAlwaysAlive(D) || getImpl(impl).blocksEndToLiveness[B].isLive(D);
180}
181
182bool LiveVariables::isLive(const Stmt *S, const VarDecl *D) {
183  return isAlwaysAlive(D) || getImpl(impl).stmtsToLiveness[S].isLive(D);
184}
185
186bool LiveVariables::isLive(const Stmt *Loc, const Stmt *S) {
187  return getImpl(impl).stmtsToLiveness[Loc].isLive(S);
188}
189
190//===----------------------------------------------------------------------===//
191// Dataflow computation.
192//===----------------------------------------------------------------------===//
193
194namespace {
195class TransferFunctions : public StmtVisitor<TransferFunctions> {
196  LiveVariablesImpl &LV;
197  LiveVariables::LivenessValues &val;
198  LiveVariables::Observer *observer;
199  const CFGBlock *currentBlock;
200public:
201  TransferFunctions(LiveVariablesImpl &im,
202                    LiveVariables::LivenessValues &Val,
203                    LiveVariables::Observer *Observer,
204                    const CFGBlock *CurrentBlock)
205  : LV(im), val(Val), observer(Observer), currentBlock(CurrentBlock) {}
206
207  void VisitBinaryOperator(BinaryOperator *BO);
208  void VisitBlockExpr(BlockExpr *BE);
209  void VisitDeclRefExpr(DeclRefExpr *DR);
210  void VisitDeclStmt(DeclStmt *DS);
211  void VisitObjCForCollectionStmt(ObjCForCollectionStmt *OS);
212  void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *UE);
213  void VisitUnaryOperator(UnaryOperator *UO);
214  void Visit(Stmt *S);
215};
216}
217
218static const VariableArrayType *FindVA(QualType Ty) {
219  const Type *ty = Ty.getTypePtr();
220  while (const ArrayType *VT = dyn_cast<ArrayType>(ty)) {
221    if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(VT))
222      if (VAT->getSizeExpr())
223        return VAT;
224
225    ty = VT->getElementType().getTypePtr();
226  }
227
228  return nullptr;
229}
230
231static const Stmt *LookThroughStmt(const Stmt *S) {
232  while (S) {
233    if (const Expr *Ex = dyn_cast<Expr>(S))
234      S = Ex->IgnoreParens();
235    if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(S)) {
236      S = EWC->getSubExpr();
237      continue;
238    }
239    if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(S)) {
240      S = OVE->getSourceExpr();
241      continue;
242    }
243    break;
244  }
245  return S;
246}
247
248static void AddLiveStmt(llvm::ImmutableSet<const Stmt *> &Set,
249                        llvm::ImmutableSet<const Stmt *>::Factory &F,
250                        const Stmt *S) {
251  Set = F.add(Set, LookThroughStmt(S));
252}
253
254void TransferFunctions::Visit(Stmt *S) {
255  if (observer)
256    observer->observeStmt(S, currentBlock, val);
257
258  StmtVisitor<TransferFunctions>::Visit(S);
259
260  if (isa<Expr>(S)) {
261    val.liveStmts = LV.SSetFact.remove(val.liveStmts, S);
262  }
263
264  // Mark all children expressions live.
265
266  switch (S->getStmtClass()) {
267    default:
268      break;
269    case Stmt::StmtExprClass: {
270      // For statement expressions, look through the compound statement.
271      S = cast<StmtExpr>(S)->getSubStmt();
272      break;
273    }
274    case Stmt::CXXMemberCallExprClass: {
275      // Include the implicit "this" pointer as being live.
276      CXXMemberCallExpr *CE = cast<CXXMemberCallExpr>(S);
277      if (Expr *ImplicitObj = CE->getImplicitObjectArgument()) {
278        AddLiveStmt(val.liveStmts, LV.SSetFact, ImplicitObj);
279      }
280      break;
281    }
282    case Stmt::ObjCMessageExprClass: {
283      // In calls to super, include the implicit "self" pointer as being live.
284      ObjCMessageExpr *CE = cast<ObjCMessageExpr>(S);
285      if (CE->getReceiverKind() == ObjCMessageExpr::SuperInstance)
286        val.liveDecls = LV.DSetFact.add(val.liveDecls,
287                                        LV.analysisContext.getSelfDecl());
288      break;
289    }
290    case Stmt::DeclStmtClass: {
291      const DeclStmt *DS = cast<DeclStmt>(S);
292      if (const VarDecl *VD = dyn_cast<VarDecl>(DS->getSingleDecl())) {
293        for (const VariableArrayType* VA = FindVA(VD->getType());
294             VA != nullptr; VA = FindVA(VA->getElementType())) {
295          AddLiveStmt(val.liveStmts, LV.SSetFact, VA->getSizeExpr());
296        }
297      }
298      break;
299    }
300    case Stmt::PseudoObjectExprClass: {
301      // A pseudo-object operation only directly consumes its result
302      // expression.
303      Expr *child = cast<PseudoObjectExpr>(S)->getResultExpr();
304      if (!child) return;
305      if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(child))
306        child = OV->getSourceExpr();
307      child = child->IgnoreParens();
308      val.liveStmts = LV.SSetFact.add(val.liveStmts, child);
309      return;
310    }
311
312    // FIXME: These cases eventually shouldn't be needed.
313    case Stmt::ExprWithCleanupsClass: {
314      S = cast<ExprWithCleanups>(S)->getSubExpr();
315      break;
316    }
317    case Stmt::CXXBindTemporaryExprClass: {
318      S = cast<CXXBindTemporaryExpr>(S)->getSubExpr();
319      break;
320    }
321    case Stmt::UnaryExprOrTypeTraitExprClass: {
322      // No need to unconditionally visit subexpressions.
323      return;
324    }
325  }
326
327  for (Stmt::child_iterator it = S->child_begin(), ei = S->child_end();
328       it != ei; ++it) {
329    if (Stmt *child = *it)
330      AddLiveStmt(val.liveStmts, LV.SSetFact, child);
331  }
332}
333
334void TransferFunctions::VisitBinaryOperator(BinaryOperator *B) {
335  if (B->isAssignmentOp()) {
336    if (!LV.killAtAssign)
337      return;
338
339    // Assigning to a variable?
340    Expr *LHS = B->getLHS()->IgnoreParens();
341
342    if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(LHS))
343      if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
344        // Assignments to references don't kill the ref's address
345        if (VD->getType()->isReferenceType())
346          return;
347
348        if (!isAlwaysAlive(VD)) {
349          // The variable is now dead.
350          val.liveDecls = LV.DSetFact.remove(val.liveDecls, VD);
351        }
352
353        if (observer)
354          observer->observerKill(DR);
355      }
356  }
357}
358
359void TransferFunctions::VisitBlockExpr(BlockExpr *BE) {
360  AnalysisDeclContext::referenced_decls_iterator I, E;
361  std::tie(I, E) =
362    LV.analysisContext.getReferencedBlockVars(BE->getBlockDecl());
363  for ( ; I != E ; ++I) {
364    const VarDecl *VD = *I;
365    if (isAlwaysAlive(VD))
366      continue;
367    val.liveDecls = LV.DSetFact.add(val.liveDecls, VD);
368  }
369}
370
371void TransferFunctions::VisitDeclRefExpr(DeclRefExpr *DR) {
372  if (const VarDecl *D = dyn_cast<VarDecl>(DR->getDecl()))
373    if (!isAlwaysAlive(D) && LV.inAssignment.find(DR) == LV.inAssignment.end())
374      val.liveDecls = LV.DSetFact.add(val.liveDecls, D);
375}
376
377void TransferFunctions::VisitDeclStmt(DeclStmt *DS) {
378  for (const auto *DI : DS->decls())
379    if (const auto *VD = dyn_cast<VarDecl>(DI)) {
380      if (!isAlwaysAlive(VD))
381        val.liveDecls = LV.DSetFact.remove(val.liveDecls, VD);
382    }
383}
384
385void TransferFunctions::VisitObjCForCollectionStmt(ObjCForCollectionStmt *OS) {
386  // Kill the iteration variable.
387  DeclRefExpr *DR = nullptr;
388  const VarDecl *VD = nullptr;
389
390  Stmt *element = OS->getElement();
391  if (DeclStmt *DS = dyn_cast<DeclStmt>(element)) {
392    VD = cast<VarDecl>(DS->getSingleDecl());
393  }
394  else if ((DR = dyn_cast<DeclRefExpr>(cast<Expr>(element)->IgnoreParens()))) {
395    VD = cast<VarDecl>(DR->getDecl());
396  }
397
398  if (VD) {
399    val.liveDecls = LV.DSetFact.remove(val.liveDecls, VD);
400    if (observer && DR)
401      observer->observerKill(DR);
402  }
403}
404
405void TransferFunctions::
406VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *UE)
407{
408  // While sizeof(var) doesn't technically extend the liveness of 'var', it
409  // does extent the liveness of metadata if 'var' is a VariableArrayType.
410  // We handle that special case here.
411  if (UE->getKind() != UETT_SizeOf || UE->isArgumentType())
412    return;
413
414  const Expr *subEx = UE->getArgumentExpr();
415  if (subEx->getType()->isVariableArrayType()) {
416    assert(subEx->isLValue());
417    val.liveStmts = LV.SSetFact.add(val.liveStmts, subEx->IgnoreParens());
418  }
419}
420
421void TransferFunctions::VisitUnaryOperator(UnaryOperator *UO) {
422  // Treat ++/-- as a kill.
423  // Note we don't actually have to do anything if we don't have an observer,
424  // since a ++/-- acts as both a kill and a "use".
425  if (!observer)
426    return;
427
428  switch (UO->getOpcode()) {
429  default:
430    return;
431  case UO_PostInc:
432  case UO_PostDec:
433  case UO_PreInc:
434  case UO_PreDec:
435    break;
436  }
437
438  if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(UO->getSubExpr()->IgnoreParens()))
439    if (isa<VarDecl>(DR->getDecl())) {
440      // Treat ++/-- as a kill.
441      observer->observerKill(DR);
442    }
443}
444
445LiveVariables::LivenessValues
446LiveVariablesImpl::runOnBlock(const CFGBlock *block,
447                              LiveVariables::LivenessValues val,
448                              LiveVariables::Observer *obs) {
449
450  TransferFunctions TF(*this, val, obs, block);
451
452  // Visit the terminator (if any).
453  if (const Stmt *term = block->getTerminator())
454    TF.Visit(const_cast<Stmt*>(term));
455
456  // Apply the transfer function for all Stmts in the block.
457  for (CFGBlock::const_reverse_iterator it = block->rbegin(),
458       ei = block->rend(); it != ei; ++it) {
459    const CFGElement &elem = *it;
460
461    if (Optional<CFGAutomaticObjDtor> Dtor =
462            elem.getAs<CFGAutomaticObjDtor>()) {
463      val.liveDecls = DSetFact.add(val.liveDecls, Dtor->getVarDecl());
464      continue;
465    }
466
467    if (!elem.getAs<CFGStmt>())
468      continue;
469
470    const Stmt *S = elem.castAs<CFGStmt>().getStmt();
471    TF.Visit(const_cast<Stmt*>(S));
472    stmtsToLiveness[S] = val;
473  }
474  return val;
475}
476
477void LiveVariables::runOnAllBlocks(LiveVariables::Observer &obs) {
478  const CFG *cfg = getImpl(impl).analysisContext.getCFG();
479  for (CFG::const_iterator it = cfg->begin(), ei = cfg->end(); it != ei; ++it)
480    getImpl(impl).runOnBlock(*it, getImpl(impl).blocksEndToLiveness[*it], &obs);
481}
482
483LiveVariables::LiveVariables(void *im) : impl(im) {}
484
485LiveVariables::~LiveVariables() {
486  delete (LiveVariablesImpl*) impl;
487}
488
489LiveVariables *
490LiveVariables::computeLiveness(AnalysisDeclContext &AC,
491                                 bool killAtAssign) {
492
493  // No CFG?  Bail out.
494  CFG *cfg = AC.getCFG();
495  if (!cfg)
496    return nullptr;
497
498  // The analysis currently has scalability issues for very large CFGs.
499  // Bail out if it looks too large.
500  if (cfg->getNumBlockIDs() > 300000)
501    return nullptr;
502
503  LiveVariablesImpl *LV = new LiveVariablesImpl(AC, killAtAssign);
504
505  // Construct the dataflow worklist.  Enqueue the exit block as the
506  // start of the analysis.
507  DataflowWorklist worklist(*cfg, AC);
508  llvm::BitVector everAnalyzedBlock(cfg->getNumBlockIDs());
509
510  // FIXME: we should enqueue using post order.
511  for (CFG::const_iterator it = cfg->begin(), ei = cfg->end(); it != ei; ++it) {
512    const CFGBlock *block = *it;
513    worklist.enqueueBlock(block);
514
515    // FIXME: Scan for DeclRefExprs using in the LHS of an assignment.
516    // We need to do this because we lack context in the reverse analysis
517    // to determine if a DeclRefExpr appears in such a context, and thus
518    // doesn't constitute a "use".
519    if (killAtAssign)
520      for (CFGBlock::const_iterator bi = block->begin(), be = block->end();
521           bi != be; ++bi) {
522        if (Optional<CFGStmt> cs = bi->getAs<CFGStmt>()) {
523          if (const BinaryOperator *BO =
524                  dyn_cast<BinaryOperator>(cs->getStmt())) {
525            if (BO->getOpcode() == BO_Assign) {
526              if (const DeclRefExpr *DR =
527                    dyn_cast<DeclRefExpr>(BO->getLHS()->IgnoreParens())) {
528                LV->inAssignment[DR] = 1;
529              }
530            }
531          }
532        }
533      }
534  }
535
536  worklist.sortWorklist();
537
538  while (const CFGBlock *block = worklist.dequeue()) {
539    // Determine if the block's end value has changed.  If not, we
540    // have nothing left to do for this block.
541    LivenessValues &prevVal = LV->blocksEndToLiveness[block];
542
543    // Merge the values of all successor blocks.
544    LivenessValues val;
545    for (CFGBlock::const_succ_iterator it = block->succ_begin(),
546                                       ei = block->succ_end(); it != ei; ++it) {
547      if (const CFGBlock *succ = *it) {
548        val = LV->merge(val, LV->blocksBeginToLiveness[succ]);
549      }
550    }
551
552    if (!everAnalyzedBlock[block->getBlockID()])
553      everAnalyzedBlock[block->getBlockID()] = true;
554    else if (prevVal.equals(val))
555      continue;
556
557    prevVal = val;
558
559    // Update the dataflow value for the start of this block.
560    LV->blocksBeginToLiveness[block] = LV->runOnBlock(block, val);
561
562    // Enqueue the value to the predecessors.
563    worklist.enqueuePredecessors(block);
564  }
565
566  return new LiveVariables(LV);
567}
568
569void LiveVariables::dumpBlockLiveness(const SourceManager &M) {
570  getImpl(impl).dumpBlockLiveness(M);
571}
572
573void LiveVariablesImpl::dumpBlockLiveness(const SourceManager &M) {
574  std::vector<const CFGBlock *> vec;
575  for (llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>::iterator
576       it = blocksEndToLiveness.begin(), ei = blocksEndToLiveness.end();
577       it != ei; ++it) {
578    vec.push_back(it->first);
579  }
580  std::sort(vec.begin(), vec.end(), [](const CFGBlock *A, const CFGBlock *B) {
581    return A->getBlockID() < B->getBlockID();
582  });
583
584  std::vector<const VarDecl*> declVec;
585
586  for (std::vector<const CFGBlock *>::iterator
587        it = vec.begin(), ei = vec.end(); it != ei; ++it) {
588    llvm::errs() << "\n[ B" << (*it)->getBlockID()
589                 << " (live variables at block exit) ]\n";
590
591    LiveVariables::LivenessValues vals = blocksEndToLiveness[*it];
592    declVec.clear();
593
594    for (llvm::ImmutableSet<const VarDecl *>::iterator si =
595          vals.liveDecls.begin(),
596          se = vals.liveDecls.end(); si != se; ++si) {
597      declVec.push_back(*si);
598    }
599
600    std::sort(declVec.begin(), declVec.end(), [](const Decl *A, const Decl *B) {
601      return A->getLocStart() < B->getLocStart();
602    });
603
604    for (std::vector<const VarDecl*>::iterator di = declVec.begin(),
605         de = declVec.end(); di != de; ++di) {
606      llvm::errs() << " " << (*di)->getDeclName().getAsString()
607                   << " <";
608      (*di)->getLocation().dump(M);
609      llvm::errs() << ">\n";
610    }
611  }
612  llvm::errs() << "\n";
613}
614
615const void *LiveVariables::getTag() { static int x; return &x; }
616const void *RelaxedLiveVariables::getTag() { static int x; return &x; }
617