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