contrib/llvm/tools/clang/lib/Analysis/LiveVariables.cpp

   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; }