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