[Analys] Added new context analys for BB/Inst

[dbakunevich]

Summary

Added a new analysis pass that allows collecting context information
about instructions and basic blocks. This analysis will help to give more
meaningful names for instructions and basic blocks in the MetaRenamer pass.
Also, this pass collects the full context for the given instruction/basic block.

[apilipenko]

I don't think a separate analysis is justified here. If you want to improve the meta renamer just make the necessary changes there.

I'm not sure why you need "Context" info for meta renames.

[mkazantsev]

Actually it was I who proposed Dmitry to split it off into a separate analysis. The main advantage of this approach is that we can then create some static analysis tools that don't necessarily modify the IR to give you the same info.

[nikic]

In D146423#4208625, @mkazantsev wrote:

Actually it was I who proposed Dmitry to split it off into a separate analysis. The main advantage of this approach is that we can then create some static analysis tools that don't necessarily modify the IR to give you the same info.

I think it would still be preferable to start implementing this as a MetaRenamer improvement, and then extracting it into a separate analysis if we have an actual use case for it.

[mkazantsev]

llvm/lib/Analysis/ContextAnalysis.cpp

14–15

StringRef (here and everywhere)

16

.empty() (here and everywhere)

[mkazantsev]

Marking to remove it from my review list, please update if you have plans on it. Let's start from MetaRenamer changes.

llvm/include/llvm/Analysis/ContextAnalysis.h

+//===- ContextAnalysis.h - Analysis of BB and Instructions -------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// 
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CONTEXT_ANALYSIS_H
+#define LLVM_CONTEXT_ANALYSIS_H
+
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/ScalarEvolution.h"
+
+namespace llvm {
+
+class Value;
+class PHINode;
+class Function;
+
+class ContextInfo {
+public:
+  /// Construct an empty ContextInfo.
+  ContextInfo(const Function &F, const ScalarEvolution &SE, const LoopInfo &LI)
+      : F(F), SE(SE), LI(LI) {}
+
+  void createContext();
+
+  const std::optional<StringRef> getContextForValue(const Value *V);
+  const std::optional<StringRef> getContextForBB(const BasicBlock *BB);
+  const std::optional<StringRef> getContextForInst(const Instruction *PN);
+
+  const std::optional<StringRef> getNameForValue(const Value *V);
+  const std::optional<StringRef> getNameForBB(const BasicBlock *BB);
+  const std::optional<StringRef> getNameForInst(const Instruction *PN);
+
+  /// Free the memory used by this class.
+  void releaseMemory();
+
+  /// Print out the values currently in the cache.
+  void print(raw_ostream &OS) const;
+
+  /// Handle invalidation events in the new pass manager.
+  bool invalidate(Function &, const PreservedAnalyses &,
+                  FunctionAnalysisManager::Invalidator &);
+
+private:
+  using ContextMapBB =
+      DenseMap<const BasicBlock *, std::pair<std::string, std::string> >;
+  using ContextMapInst =
+      DenseMap<const Instruction *, std::pair<std::string, std::string> >;
+
+  ContextMapBB ContextBB;
+
+  ContextMapInst ContextInst;
+
+  const Function &F;
+
+  const ScalarEvolution &SE;
+
+  const LoopInfo &LI;
+
+  void createContextForBB(const BasicBlock *BB);
+
+  void createContextForInst(const Instruction *Inst);
+};
+
+class ContextAnalysis : public AnalysisInfoMixin<ContextAnalysis> {
+  friend AnalysisInfoMixin<ContextAnalysis>;
+  static AnalysisKey Key;
+
+public:
+  using Result = ContextInfo;
+  ContextInfo run(Function &F, FunctionAnalysisManager &);
+};
+
+class ContextInfoPrinterPass : public PassInfoMixin<ContextInfoPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit ContextInfoPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_CONTEXT_ANALYSIS_H

llvm/lib/Analysis/CMakeLists.txt

add_llvm_component_library(LLVMAnalysis
   CGSCCPassManager.cpp
   CallGraph.cpp
   CallGraphSCCPass.cpp
   CallPrinter.cpp
   CaptureTracking.cpp
   CmpInstAnalysis.cpp
   CostModel.cpp
   CodeMetrics.cpp
+  ContextAnalysis.cpp
   ConstantFolding.cpp
   CycleAnalysis.cpp
   DDG.cpp
   DDGPrinter.cpp
   ConstraintSystem.cpp
   Delinearization.cpp
   DemandedBits.cpp
   DependenceAnalysis.cpp

llvm/lib/Analysis/ContextAnalysis.cpp

+//===- ContextAnalysis.cpp - Analysis of BB and Instructions --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/ContextAnalysis.h"
+
+using namespace llvm;
+
+static std::string ConcatWithDelimeter(std::string Base, std::string Attaching,
+                                       std::string Delimeter = "_") {
+  if (Base == "")
+    return Attaching;
+  return Base + Delimeter + Attaching;
+}
+
+static std::string SetName(std::string Name, std::string Value) {
+  if (Name == "")
+    return Value;
+  return Name;
+}
+
+void ContextInfo::createContext() {
+  for (const BasicBlock &BB : F) {
+    createContextForBB(&BB);
+    for (const Instruction &I : BB)
+      createContextForInst(&I);
+  }
+  return;
+}
+
+const std::optional<StringRef> ContextInfo::getContextForValue(const Value *V) {
+  if (isa<BasicBlock>(V))
+    return getContextForBB(cast<BasicBlock>(V));
+  if (isa<Instruction>(V))
+    return getContextForInst(cast<Instruction>(V));
+  return std::nullopt;
+}
+
+const std::optional<StringRef>
+ContextInfo::getContextForBB(const BasicBlock *BB) {
+  if (ContextBB.contains(BB))
+    return StringRef(ContextBB[BB].second);
+  return std::nullopt;
+}
+
+const std::optional<StringRef>
+ContextInfo::getContextForInst(const Instruction *Inst) {
+  if (ContextInst.contains(Inst))
+    return StringRef(ContextInst[Inst].second);
+  return std::nullopt;
+}
+
+const std::optional<StringRef> ContextInfo::getNameForValue(const Value *V) {
+  if (isa<BasicBlock>(V))
+    return getNameForBB(cast<BasicBlock>(V));
+  if (isa<Instruction>(V))
+    return getNameForInst(cast<Instruction>(V));
+  return std::nullopt;
+}
+
+const std::optional<StringRef> ContextInfo::getNameForBB(const BasicBlock *BB) {
+  if (ContextBB.contains(BB))
+    return StringRef(ContextBB[BB].first);
+  return std::nullopt;
+}
+
+const std::optional<StringRef>
+ContextInfo::getNameForInst(const Instruction *Inst) {
+  if (ContextInst.contains(Inst))
+    return StringRef(ContextInst[Inst].first);
+  return std::nullopt;
+}
+
+void ContextInfo::releaseMemory() {
+  ContextInst.clear();
+  ContextBB.clear();
+}
+
+void ContextInfo::print(raw_ostream &OS) const {
+  OS << "Basic blocks: \n";
+  for (const auto &ItBBMap : ContextBB) {
+    OS << "BB " << ItBBMap.first->getName();
+    if (ItBBMap.second.first == "") {
+      OS << " hasn't information about this BB\n";
+      continue;
+    }
+    OS << " has possible name: " << ItBBMap.second.first;
+    OS << ". And next context: " << ItBBMap.second.second;
+    OS << "\n";
+  }
+  OS << "Instructions: \n";
+  for (const auto &ItInstMap : ContextInst) {
+    OS << "Inst " << ItInstMap.first->getName();
+    if (ItInstMap.second.first == "") {
+      OS << " hasn't information about this Inst\n";
+      continue;
+    }
+    OS << "has possible name: " << ItInstMap.second.first;
+    OS << ". And next context: " << ItInstMap.second.second;
+    OS << "\n";
+  }
+}
+
+bool ContextInfo::invalidate(Function &, const PreservedAnalyses &PA,
+                             FunctionAnalysisManager::Invalidator &) {
+  // ContextAnalysis is invalidated if it isn't preserved.
+  auto PAC = PA.getChecker<ContextAnalysis>();
+  return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function> >());
+}
+
+void ContextInfo::createContextForBB(const BasicBlock *BB) {
+  std::string Name = "";
+  std::string Ctx = "";
+  if (ContextBB.contains(BB)) {
+    Name = ContextBB[BB].first;
+    Ctx = ContextBB[BB].second;
+  }
+
+  if (BB->isEntryBlock()) {
+    Name = SetName(Name, "entry");
+    Ctx = ConcatWithDelimeter(Ctx, BB->getName().str() + " is entry", " | ");
+  }
+
+  if (isa<UnreachableInst>(BB->getTerminator())) {
+    Name = SetName(Name, "unreachable");
+    Ctx = ConcatWithDelimeter(Ctx, BB->getName().str() + " is unreachable",
+                              " | ");
+  }
+
+  if (isa<ReturnInst>(BB->getTerminator())) {
+    Name = SetName(Name, "exit");
+    Ctx = ConcatWithDelimeter(Ctx, BB->getName().str() + " is exit", " | ");
+  }
+
+  if (LI.isLoopHeader(BB)) {
+    Name = SetName(Name, "loop.header");
+    Ctx = ConcatWithDelimeter(Ctx, BB->getName().str() + " is loop header",
+                              " | ");
+  }
+
+  if (auto *L = LI.getLoopFor(BB)) {
+    if (L->isLoopLatch(BB)) {
+      Name = SetName(Name, "loop.latch");
+      Ctx = ConcatWithDelimeter(Ctx, BB->getName().str() + " is loop latch",
+                                " | ");
+    }
+    if (L->isLoopExiting(BB)) {
+      Name = SetName(Name, "loop.exit");
+      Ctx = ConcatWithDelimeter(Ctx, BB->getName().str() + " is loop exiting",
+                                " | ");
+    }
+    Name = SetName(Name, "loop.body");
+    if (Ctx == "")
+      Ctx = ConcatWithDelimeter(Ctx, BB->getName().str() + " is loop body",
+                                " | ");
+  }
+  ContextBB[BB] = std::pair<std::string, std::string>{ Name, Ctx };
+}
+
+void ContextInfo::createContextForInst(const Instruction *Inst) {
+  std::string Name = "";
+  std::string Ctx = "";
+  if (ContextInst.contains(Inst)) {
+    Name = ContextInst[Inst].first;
+    Ctx = ContextInst[Inst].second;
+  }
+  if (isa<PHINode>(Inst)) {
+    Name = SetName(Name, "phi.node");
+    Ctx =
+        ConcatWithDelimeter(Ctx, Inst->getName().str() + " is phi node", " | ");
+  }
+  if (isa<ICmpInst>(Inst)) {
+    Name = SetName(Name, "icmp");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is icmp", " | ");
+  }
+  if (Inst->isTerminator()) {
+    Name = SetName(Name, "terminator");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is terminator",
+                              " | ");
+  }
+  if (Inst->isUnaryOp()) {
+    Name = SetName(Name, "unary.operand");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is unary operand",
+                              " | ");
+  }
+  if (Inst->isBinaryOp()) {
+    Name = SetName(Name, "binary.operand");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is binary operand",
+                              " | ");
+  }
+  if (Inst->isIntDivRem()) {
+    Name = SetName(Name, "int.div.rem");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is int div rem",
+                              " | ");
+  }
+  if (Inst->isShift()) {
+    Name = SetName(Name, "shift");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is shift", " | ");
+  }
+  if (Inst->isCast()) {
+    Name = SetName(Name, "cast");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is cast", " | ");
+  }
+  if (Inst->isFuncletPad()) {
+    Name = SetName(Name, "funclet.pad");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is funclet pad",
+                              " | ");
+  }
+  if (Inst->isExceptionalTerminator()) {
+    Name = SetName(Name, "exceptional.terminator");
+    Ctx = ConcatWithDelimeter(
+        Ctx, Inst->getName().str() + " is exceptional terminator", " | ");
+  }
+  if (Inst->isLogicalShift()) {
+    Name = SetName(Name, "logical.shift");
+    Ctx = ConcatWithDelimeter(Ctx, Inst->getName().str() + " is logical shift",
+                              " | ");
+  }
+  if (Inst->isArithmeticShift()) {
+    Name = SetName(Name, "ArithmeticShift");
+    Ctx = ConcatWithDelimeter(
+        Ctx, Inst->getName().str() + " is arithmetic shift", " | ");
+  }
+  if (Inst->isBitwiseLogicOp()) {
+    Name = SetName(Name, "BitwiseLogicOp");
+    Ctx = ConcatWithDelimeter(
+        Ctx, Inst->getName().str() + " is bitwise logical operand", " | ");
+  }
+
+  ContextInst[Inst] = std::pair<std::string, std::string>{ Name, Ctx };
+}
+
+AnalysisKey ContextAnalysis::Key;
+ContextInfo ContextAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
+  auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
+  auto &LI = AM.getResult<LoopAnalysis>(F);
+  ContextInfo CI(F, SE, LI);
+  CI.createContext();
+  return CI;
+}
+
+PreservedAnalyses ContextInfoPrinterPass::run(Function &F,
+                                              FunctionAnalysisManager &AM) {
+  OS << "Context info for function: " << F.getName() << "\n";
+  AM.getResult<ContextAnalysis>(F).print(OS);
+  return PreservedAnalyses::all();
+}

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/CFGPrinter.h"
 #include "llvm/Analysis/CFGSCCPrinter.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallPrinter.h"
 #include "llvm/Analysis/CostModel.h"
+#include "llvm/Analysis/ContextAnalysis.h"
 #include "llvm/Analysis/CycleAnalysis.h"
 #include "llvm/Analysis/DDG.h"
 #include "llvm/Analysis/DDGPrinter.h"
 #include "llvm/Analysis/Delinearization.h"
 #include "llvm/Analysis/DemandedBits.h"
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/DivergenceAnalysis.h"
 #include "llvm/Analysis/DomPrinter.h"

llvm/lib/Passes/PassRegistry.def

 #ifndef FUNCTION_ANALYSIS
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 #endif
 FUNCTION_ANALYSIS("aa", AAManager())
 FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis())
 FUNCTION_ANALYSIS("block-freq", BlockFrequencyAnalysis())
 FUNCTION_ANALYSIS("branch-prob", BranchProbabilityAnalysis())
 FUNCTION_ANALYSIS("cycles", CycleAnalysis())
+FUNCTION_ANALYSIS("context-info", ContextAnalysis())
 FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis())
 FUNCTION_ANALYSIS("postdomtree", PostDominatorTreeAnalysis())
 FUNCTION_ANALYSIS("demanded-bits", DemandedBitsAnalysis())
 FUNCTION_ANALYSIS("domfrontier", DominanceFrontierAnalysis())
 FUNCTION_ANALYSIS("func-properties", FunctionPropertiesAnalysis())
 FUNCTION_ANALYSIS("loops", LoopAnalysis())
 FUNCTION_ANALYSIS("access-info", LoopAccessAnalysis())
 FUNCTION_ANALYSIS("lazy-value-info", LazyValueAnalysis())

 FUNCTION_PASS("pa-eval", PAEvalPass())
 FUNCTION_PASS("pgo-memop-opt", PGOMemOPSizeOpt())
 FUNCTION_PASS("place-safepoints", PlaceSafepointsPass())
 FUNCTION_PASS("print", PrintFunctionPass(dbgs()))
 FUNCTION_PASS("print<assumptions>", AssumptionPrinterPass(dbgs()))
 FUNCTION_PASS("print<block-freq>", BlockFrequencyPrinterPass(dbgs()))
 FUNCTION_PASS("print<branch-prob>", BranchProbabilityPrinterPass(dbgs()))
 FUNCTION_PASS("print<cost-model>", CostModelPrinterPass(dbgs()))
+FUNCTION_PASS("print<context-info>", ContextInfoPrinterPass(dbgs()))
 FUNCTION_PASS("print<cycles>", CycleInfoPrinterPass(dbgs()))
 FUNCTION_PASS("print<da>", DependenceAnalysisPrinterPass(dbgs()))
 FUNCTION_PASS("print<divergence>", DivergenceAnalysisPrinterPass(dbgs()))
 FUNCTION_PASS("print<domtree>", DominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<postdomtree>", PostDominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<delinearization>", DelinearizationPrinterPass(dbgs()))
 FUNCTION_PASS("print<demanded-bits>", DemandedBitsPrinterPass(dbgs()))
 FUNCTION_PASS("print<domfrontier>", DominanceFrontierPrinterPass(dbgs()))

llvm/unittests/Analysis/CMakeLists.txt

set(ANALYSIS_TEST_SOURCES
   BasicAliasAnalysisTest.cpp
   BlockFrequencyInfoTest.cpp
   BranchProbabilityInfoTest.cpp
   CallGraphTest.cpp
   CaptureTrackingTest.cpp
   CFGTest.cpp
   CGSCCPassManagerTest.cpp
   ConstraintSystemTest.cpp
+  ContextAnalysisTest.cpp
   DDGTest.cpp
   DivergenceAnalysisTest.cpp
   DomTreeUpdaterTest.cpp
   GlobalsModRefTest.cpp
   FunctionPropertiesAnalysisTest.cpp
   InlineCostTest.cpp
   IRSimilarityIdentifierTest.cpp
   IVDescriptorsTest.cpp

llvm/unittests/Analysis/ContextAnalysisTest.cpp

+//===- ContextAnalysisTest.cpp - Context analysis unit tests --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/ContextAnalysis.h"
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Dominators.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+static ContextInfo buildCI(Function &F) {
+  TargetLibraryInfoImpl TLII;
+  TargetLibraryInfo TLI(TLII);
+  AssumptionCache AC(F);
+  DominatorTree DT(F);
+  LoopInfo LI(DT);
+  ScalarEvolution SE(F, TLI, AC, DT, LI);
+  ContextInfo CI(F, SE, LI);
+  CI.createContext();
+  return CI;
+}
+
+TEST(ContextAnalysisTest, SimpleFunction) {
+  LLVMContext Context;
+  Module M("ContextAnalysisTest", Context);
+
+  // Generate a function like below:
+  // define void @foo() {
+  // entry:
+  //   br label %for.cond
+  // 
+  // for.cond:           ; preds = %for.end, %entry
+  //   %pnode = phi i32 [ 10, %entry ], [ %dec, %for.inc ]
+  //   %cmp.unreach = icmp sgt i32 %pnode, -10
+  //   br i1 %cmp.unreach, label %for.inc, label %unreach
+  // 
+  // for.inc:            ; preds = %for.cond
+  //   %dec = add nsw i32 %pnode, -1
+  //   br label %for.end
+  // 
+  // unreach:            ; preds = %for.cond
+  //   unreachable
+  // 
+  // for.end:            ; preds = %for.inc
+  //   %cmp.exit = icmp sgt i32 %dec, 0
+  //   br i1 %cmp.exit, label %exit, label %for.cond
+  // 
+  // exit:               ; preds = %for.end
+  //   ret void
+  // }
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), {}, false);
+  Function *F = Function::Create(FTy, Function::ExternalLinkage, "foo", M);
+
+  BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", F);
+  BasicBlock *CondBB = BasicBlock::Create(Context, "for.cond", F);
+  BasicBlock *EndBB = BasicBlock::Create(Context, "for.end", F);
+  BasicBlock *IncBB = BasicBlock::Create(Context, "for.inc", F, EndBB);
+  BasicBlock *UnreachableBB = BasicBlock::Create(Context, "unreach", F, EndBB);
+  BasicBlock *ExitBB = BasicBlock::Create(Context, "exit", F);
+
+  Type *I32Ty = Type::getInt32Ty(Context);
+  auto *PN = PHINode::Create(I32Ty, 2, "pnode", CondBB);
+  PN->addIncoming(ConstantInt::get(Context, APInt(32, 10)), EntryBB);
+  auto *Dec = BinaryOperator::CreateNSWAdd(
+      PN, ConstantInt::get(Context, APInt(32, -1)), "dec", IncBB);
+  PN->addIncoming(Dec, IncBB);
+
+  auto *CmpUnreach = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_SGT, PN,
+                                     ConstantInt::get(Context, APInt(32, -10)),
+                                     "cmp.unreach", CondBB);
+  auto *CmpExit = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_SGT, Dec,
+                                  ConstantInt::get(Context, APInt(32, 0)),
+                                  "cmp.exit", EndBB);
+
+  BranchInst::Create(CondBB, EntryBB);
+  BranchInst::Create(IncBB, UnreachableBB, CmpUnreach, CondBB);
+  BranchInst::Create(EndBB, IncBB);
+  new UnreachableInst(Context, UnreachableBB);
+  BranchInst::Create(ExitBB, CondBB, CmpExit, EndBB);
+  ReturnInst::Create(Context, nullptr, ExitBB);
+
+  ContextInfo CI = buildCI(*F);
+  EXPECT_EQ(CI.getContextForInst(PN), "pnode is phi node");
+  EXPECT_EQ(CI.getNameForInst(PN), "phi.node");
+
+  EXPECT_EQ(CI.getContextForInst(CmpExit), "cmp.exit is icmp");
+  EXPECT_EQ(CI.getNameForInst(CmpExit), "icmp");
+
+  EXPECT_EQ(CI.getContextForInst(Dec), "dec is binary operand");
+  EXPECT_EQ(CI.getNameForInst(Dec), "binary.operand");
+
+  EXPECT_EQ(CI.getContextForBB(EntryBB), "entry is entry");
+  EXPECT_EQ(CI.getNameForBB(EntryBB), "entry");
+
+  EXPECT_EQ(CI.getContextForBB(CondBB),
+            "for.cond is loop header | for.cond is loop exiting");
+  EXPECT_EQ(CI.getNameForBB(CondBB), "loop.header");
+
+  EXPECT_EQ(CI.getContextForBB(IncBB), "for.inc is loop body");
+  EXPECT_EQ(CI.getNameForBB(IncBB), "loop.body");
+
+  EXPECT_EQ(CI.getContextForBB(UnreachableBB), "unreach is unreachable");
+  EXPECT_EQ(CI.getNameForBB(UnreachableBB), "unreachable");
+
+  EXPECT_EQ(CI.getContextForBB(EndBB),
+            "for.end is loop latch | for.end is loop exiting");
+  EXPECT_EQ(CI.getNameForBB(EndBB), "loop.latch");
+
+  EXPECT_EQ(CI.getContextForBB(ExitBB), "exit is exit");
+  EXPECT_EQ(CI.getNameForBB(ExitBB), "exit");
+}