[WIP] Automated loop analysis tool

[virnarula]

Summary

[Loop] Emit remark for extracted loops

[Loop] Fix remark emitting bug

Bug fix to recalculate analyses on cloned module

[LoopAnalysis] Add test cases for remark emitting

[LoopAnalysis] Assertions, debug info, clean up

[LoopAnalysis] Add remark extraction tool module

[LoopAnalysis] Emit remarks for extraction stats

[LoopAnalysis] Add vectorization analysis

[LoopAnalysis] Add summary stats for bounds

[LoopAnalyzer] Add basic testing

[LoopAnalyzer] Add DCE pass before extraction

[LoopAnalyzer] Add Remarks and simplification

[LoopAnalyzer] Add Remark type support

[LoopAnalyzer] Add basic querying

[LoopAnalysis] Add basic PGO functionality

Changes in progress

llvm/include/llvm/Transforms/IPO/LoopExtractionAnalysis.h

 
 //===- LoopExtractionAnalysis.h - Loop Extraction Analysis ---------*- 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
 //
 //===----------------------------------------------------------------------===//

 /// Pass to perform interprocedural constant propagation.
 class LoopExtractionAnalysisPass : public PassInfoMixin<LoopExtractionAnalysisPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 
 } // end namespace llvm
 
-#endif // LLVM_TRANSFORMS_LOOP_EXTRACTION_ANALYSIS_H
+#endif // LLVM_TRANSFORMS_LOOP_EXTRACTION_ANALYSIS_H
 

llvm/lib/Passes/PassBuilderPipelines.cpp

 //===- Construction of pass pipelines -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 /// \file

 #include "llvm/Transforms/IPO/GlobalDCE.h"
 #include "llvm/Transforms/IPO/GlobalOpt.h"
 #include "llvm/Transforms/IPO/GlobalSplit.h"
 #include "llvm/Transforms/IPO/HotColdSplitting.h"
 #include "llvm/Transforms/IPO/IROutliner.h"
 #include "llvm/Transforms/IPO/InferFunctionAttrs.h"
 #include "llvm/Transforms/IPO/Inliner.h"
 #include "llvm/Transforms/IPO/LowerTypeTests.h"
+#include "llvm/Transforms/IPO/LoopExtractionAnalysis.h"
 #include "llvm/Transforms/IPO/MergeFunctions.h"
 #include "llvm/Transforms/IPO/ModuleInliner.h"
 #include "llvm/Transforms/IPO/OpenMPOpt.h"
 #include "llvm/Transforms/IPO/PartialInlining.h"
 #include "llvm/Transforms/IPO/SCCP.h"
 #include "llvm/Transforms/IPO/SampleProfile.h"
 #include "llvm/Transforms/IPO/SampleProfileProbe.h"
 #include "llvm/Transforms/IPO/SyntheticCountsPropagation.h"
static bool isLTOPreLink(ThinOrFullLTOPhase Phase) {
   return Phase == ThinOrFullLTOPhase::ThinLTOPreLink ||
          Phase == ThinOrFullLTOPhase::FullLTOPreLink;
 }
 
 // TODO: Investigate the cost/benefit of tail call elimination on debugging.
 FunctionPassManager
 PassBuilder::buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
                                                    ThinOrFullLTOPhase Phase) {
   
   FunctionPassManager FPM;
 
   // Form SSA out of local memory accesses after breaking apart aggregates into
   // scalars.
   FPM.addPass(SROAPass());
 
   // Catch trivial redundancies
   FPM.addPass(EarlyCSEPass(true /* Enable mem-ssa. */));
PassBuilder::buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
 
   // We provide the opt remark emitter pass for LICM to use. We only need to do
   // this once as it is immutable.
   FPM.addPass(
       RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function>());
   FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM1),
                                               /*UseMemorySSA=*/true,
                                               /*UseBlockFrequencyInfo=*/true));
+  
   FPM.addPass(
       SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(true)));
   FPM.addPass(InstCombinePass());
   // The loop passes in LPM2 (LoopFullUnrollPass) do not preserve MemorySSA.
   // *All* loop passes must preserve it, in order to be able to use it.
   FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM2),
                                               /*UseMemorySSA=*/false,
                                               /*UseBlockFrequencyInfo=*/false));
PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
   if (PGOOpt && Phase != ThinOrFullLTOPhase::ThinLTOPostLink &&
       PGOOpt->CSAction == PGOOptions::CSIRInstr)
     MPM.addPass(PGOInstrumentationGenCreateVar(PGOOpt->CSProfileGenFile));
 
   // Synthesize function entry counts for non-PGO compilation.
   if (EnableSyntheticCounts && !PGOOpt)
     MPM.addPass(SyntheticCountsPropagation());
 
+  MPM.addPass(createModuleToFunctionPassAdaptor(PromotePass()));
+  // MPM.addPass(LoopExtractionAnalysisPass());
+
   if (EnableModuleInliner)
     MPM.addPass(buildModuleInlinerPipeline(Level, Phase));
   else
     MPM.addPass(buildInlinerPipeline(Level, Phase));
 
   MPM.addPass(CoroCleanupPass());
 
   if (EnableMemProfiler && Phase != ThinOrFullLTOPhase::ThinLTOPreLink) {

 
 ModulePassManager
 PassBuilder::buildModuleOptimizationPipeline(OptimizationLevel Level,
                                              ThinOrFullLTOPhase LTOPhase) {
   const bool LTOPreLink = (LTOPhase == ThinOrFullLTOPhase::ThinLTOPreLink ||
                            LTOPhase == ThinOrFullLTOPhase::FullLTOPreLink);
   ModulePassManager MPM;
 
+  // MPM.addPass(LoopExtractionAnalysisPass());
+
   // Optimize globals now that the module is fully simplified.
   MPM.addPass(GlobalOptPass());
   MPM.addPass(GlobalDCEPass());
 
   // Run partial inlining pass to partially inline functions that have
   // large bodies.
   if (RunPartialInlining)
     MPM.addPass(PartialInlinerPass());
PassBuilder::buildModuleOptimizationPipeline(OptimizationLevel Level,
   // Re-compute GlobalsAA here prior to function passes. This is particularly
   // useful as the above will have inlined, DCE'ed, and function-attr
   // propagated everything. We should at this point have a reasonably minimal
   // and richly annotated call graph. By computing aliasing and mod/ref
   // information for all local globals here, the late loop passes and notably
   // the vectorizer will be able to use them to help recognize vectorizable
   // memory operations.
   MPM.addPass(RecomputeGlobalsAAPass());
+  MPM.addPass(GlobalDCEPass());
+  MPM.addPass(LoopExtractionAnalysisPass());
 
   for (auto &C : OptimizerEarlyEPCallbacks)
     C(MPM, Level);
 
   FunctionPassManager OptimizePM;
   OptimizePM.addPass(Float2IntPass());
   OptimizePM.addPass(LowerConstantIntrinsicsPass());
 

llvm/lib/Transforms/IPO/LoopExtractionAnalysis.cpp

+//===- LoopExtractionAnalysis.cpp - Loop Extraction Analysis ---------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass extracts loops into remarks for future analysis
+//
+//===----------------------------------------------------------------------===//
+
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/OptimizationRemarkEmitter.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
+#include "llvm/Analysis/BlockFrequencyInfo.h"
+#include "llvm/Analysis/BranchProbabilityInfo.h"
+
+#include "llvm/Bitcode/BitcodeWriter.h"
+
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/PassManager.h"
+
+#include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/CodeExtractor.h"
+#include "llvm/Transforms/Utils/LoopSimplify.h"
+
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/StripDeadPrototypes.h"
 #include "llvm/Transforms/IPO/LoopExtractionAnalysis.h"
 
+#include "llvm/ADT/SmallSet.h"
+#include <set>
+
 using namespace llvm;
 
 #define DEBUG_TYPE "loop-extract-analysis"
 
 namespace {
+/// LoopExtractionAnalyzer contains the methods used to extract the loops of a module into remarks for later analysis.
+///
+/// This pass works in tandem with the loop-analyzer tool, which will automate the analysis of the remarks
+/// This pass is responsible for only the extraction of loops and passing additional information such as hotness for later analysis.
+///
   struct LoopExtractionAnalyzer {
     explicit LoopExtractionAnalyzer(
       function_ref<DominatorTree &(Function &)> LookupDomTree,
       function_ref<LoopInfo &(Function &)> LookupLoopInfo,
       function_ref<AssumptionCache *(Function &)> LookupAssumptionCache)
       : LookupDomTree(LookupDomTree),
         LookupLoopInfo(LookupLoopInfo),
-        LookupAssumptionCache(LookupAssumptionCache) {}
+        LookupAssumptionCache(LookupAssumptionCache),
+        NumContained(0),
+        NumNotSimplified(0),
+        NumNotExtracted(0),
+        NumExtracted(0) {}
     
     bool runOnModule(Module &M);
 
 private:
+  bool runOnFunction(Function &F);
+
+  Function *ExtractLoop(Loop *L, LoopInfo &LI, DominatorTree &DT);
+  SmallVector<Function*, 16> ExtractedLoops;
+
   function_ref<DominatorTree &(Function &)> LookupDomTree;
   function_ref<LoopInfo &(Function &)> LookupLoopInfo;
   function_ref<AssumptionCache *(Function &)> LookupAssumptionCache;
+    
+  int NumContained, NumNotSimplified, NumNotExtracted, NumExtracted;
+    
 };
 } // namespace
 
 PreservedAnalyses LoopExtractionAnalysisPass::run(Module &M, ModuleAnalysisManager &AM) {
+  // M.dump();
   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
   auto LookupDomTree = [&FAM](Function &F) -> DominatorTree & {
     return FAM.getResult<DominatorTreeAnalysis>(F);
   };
   auto LookupLoopInfo = [&FAM](Function &F) -> LoopInfo & {
     return FAM.getResult<LoopAnalysis>(F);
   };
   auto LookupAssumptionCache = [&FAM](Function &F) -> AssumptionCache * {
     return FAM.getCachedResult<AssumptionAnalysis>(F);
   };
   
    LoopExtractionAnalyzer(LookupDomTree, LookupLoopInfo, LookupAssumptionCache).runOnModule(M);
 
   return PreservedAnalyses::all();
 }
 
+Function *LoopExtractionAnalyzer::ExtractLoop(Loop *L, LoopInfo &LI, DominatorTree &DT) {
+  Function &Func = *L->getHeader()->getParent();
+  CodeExtractorAnalysisCache CEAC(Func);
+  BranchProbabilityInfo BPI(Func, LI);
+  BlockFrequencyInfo BFI(Func, BPI, LI);
+  CodeExtractor Extractor(DT, *L, false, &BFI, &BPI, nullptr);
+
+  if (Function *ExtractionLoop = Extractor.extractCodeRegion(CEAC)) {
+    return ExtractionLoop;
+  }
+
+  return nullptr;
+}
+
+bool LoopExtractionAnalyzer::runOnFunction(Function &F) {
+  if (F.empty())
+    return false;
+
+  DominatorTree DT;
+  DT.recalculate(F);
+  
+  LoopInfo LI;
+  LI.analyze(DT);
+  
+  if (LI.empty())
+    return false;
+  
+  TargetLibraryInfoImpl TLII;
+  TargetLibraryInfo TLI(TLII);
+  AssumptionCache AC(F);
+  ScalarEvolution SE(F, TLI, AC, DT, LI);
+
+  SmallVector<Loop*, 8> Loops;
+  Loops.assign(LI.begin(), LI.end());
+  SmallPtrSet<Loop*, 16> Contained;
+  for (Loop *L : Loops) {
+    // Check that loop is in simply form and not contained inside another loop
+    for (auto Child : L->getSubLoops()) {
+      Contained.insert(Child);
+    }
+
+    if (simplifyLoop(L, &DT, &LI, &SE, &AC, nullptr, false)) {
+      LLVM_DEBUG(dbgs() << "Simplified a loop!\n");
+    }
+    LLVM_DEBUG(dbgs() << "Loop dump in func " << L->getHeader()->getParent()->getName() << ":\n");
+    LLVM_DEBUG(L->dump());
+
+    if (Contained.find(L) == Contained.end()) {
+      if (L->isLoopSimplifyForm()) {
+        if (Function *ExtractedFunc = ExtractLoop(L, LI, DT)) {
+          LLVM_DEBUG(dbgs() << "Loop was extracted\n");
+          ExtractedLoops.push_back(ExtractedFunc);
+          NumExtracted++;
+        } else {
+          LLVM_DEBUG(dbgs() << "Loop could not be extracted!!\n");
+          NumNotExtracted++;
+        }
+      } else {
+        LLVM_DEBUG(errs() << "Loop is not in Loop Simply Form!\n"); NumNotSimplified++;
+      }
+    } else {
+      LLVM_DEBUG(errs() << "Loop is contained in another loop!\n");
+    }
+  }
+
+  return false;
+}
+
 bool LoopExtractionAnalyzer::runOnModule(Module &M) {
-  return true;
-}
+  if (M.empty())
+    return false;
+  
+  std::unique_ptr<Module> ClonedModPtr = CloneModule(M);
+
+  SmallVector<Function*, 16> OriginalFunctions;
+  for (auto Iter = ClonedModPtr->begin(); Iter != ClonedModPtr->end(); ++Iter) {
+    OriginalFunctions.push_back(&*Iter);
+  }
+
+  auto End = OriginalFunctions.end();
+  for (auto Iter = OriginalFunctions.begin(); Iter != End; ++Iter) {
+    runOnFunction(**Iter);
+  }
+  
+  if (ExtractedLoops.empty()) {
+    return false;
+  }
+  
+  std::vector<GlobalValue *> GVs(ExtractedLoops.begin(), ExtractedLoops.end());
+  
+  // Create remark emitter with hotness information attached
+  legacy::PassManager PM;
+  PM.add(createGVExtractionPass(GVs));
+  PM.add(createStripDeadPrototypesPass());
+  PM.run(*ClonedModPtr);
+
+  M.getContext().setDiagnosticsHotnessRequested(true);
+  ClonedModPtr->getContext().setDiagnosticsHotnessRequested(true);
+  
+  /*
+  for (auto ExtractedLoop : ExtractedLoops) {
+    std::unique_ptr<Module> ExtractedModule = CloneModule(*ClonedModPtr);
+    Function *ToExtract = ExtractedModule->getFunction(ExtractedLoop->getName());
+    std::vector<GlobalValue*> GVToExtract = { ToExtract };
+    
+    legacy::PassManager PM;
+    PM.add(createGVExtractionPass(GVs));
+    PM.add(createStripDeadPrototypesPass());
+    PM.run(*ExtractedModule);
+    
+    assert(!ExtractedModule->empty() && "Extracted Module is empty!");
+    
+    BasicBlock *LoopBB = ToExtract->getEntryBlock().getSingleSuccessor();
+    
+    DominatorTree DT;
+    LoopInfo LI;
+    DT.recalculate(*ToExtract);
+    LI.analyze(DT);
+    BranchProbabilityInfo BPI(*ToExtract, LI);
+    BlockFrequencyInfo BFI(*ToExtract, BPI, LI);
+    OptimizationRemarkEmitter ORE(ToExtract, &BFI);
+    
+    ORE.emit([&]() {
+      std::string str; raw_string_ostream rso(str);
+      ClonedModPtr->print(rso, nullptr);
+      auto DebugLoc = ToExtract->getEntryBlock().getFirstNonPHI()->getDebugLoc();
+      return OptimizationRemarkAnalysis(DEBUG_TYPE, "ModuleDump", DebugLoc, LoopBB)
+      << str;
+    });
+  }
+  */
+  
+  if (ClonedModPtr->empty()) {
+    assert(false && "Nothing after cloning!");
+  }
+ 
+  Function *Extracted = nullptr;
+  for (Function &Func : *ClonedModPtr) {
+    if (!Func.empty()) {
+      Extracted = &Func;
+      break;
+    }
+  }
+  
+  if (Extracted == nullptr) {
+    assert(false && "Failed to find extracted func!");
+  }
+  
+  BasicBlock *LoopBB = Extracted->getEntryBlock().getSingleSuccessor();
+  
+  DominatorTree DT;
+  LoopInfo LI;
+  DT.recalculate(*Extracted);
+  LI.analyze(DT);
+  BranchProbabilityInfo BPI(*Extracted, LI);
+  BlockFrequencyInfo BFI(*Extracted, BPI, LI);
+  OptimizationRemarkEmitter ORE(Extracted, &BFI);
+
+  // Emit the module to remarks
+  ORE.emit([&]() {
+    std::string str; raw_string_ostream rso(str);
+    ClonedModPtr->print(rso, nullptr);
+    auto DebugLoc = Extracted->getEntryBlock().getFirstNonPHI()->getDebugLoc();
+    return OptimizationRemarkAnalysis(DEBUG_TYPE, "ModuleDump", DebugLoc, LoopBB)
+    << str;
+  });
+  
+  // Emit extraction stats
+  ORE.emit([&]() {
+    auto DebugLoc = Extracted->getEntryBlock().getFirstNonPHI()->getDebugLoc();
+    return OptimizationRemarkAnalysis(DEBUG_TYPE, "NotSimplified", DebugLoc, LoopBB)
+    << std::to_string(NumNotSimplified);
+  });
+  
+  ORE.emit([&]() {
+    auto DebugLoc = Extracted->getEntryBlock().getFirstNonPHI()->getDebugLoc();
+    return OptimizationRemarkAnalysis(DEBUG_TYPE, "NotExtractable", DebugLoc, LoopBB)
+    << std::to_string(NumNotExtracted);
+  });
+  
+  ORE.emit([&]() {
+    auto DebugLoc = Extracted->getEntryBlock().getFirstNonPHI()->getDebugLoc();
+    return OptimizationRemarkAnalysis(DEBUG_TYPE, "Extracted", DebugLoc, LoopBB)
+    << std::to_string(NumExtracted);
+  });
+
+  ORE.emit([&] {
+    auto DebugLoc = Extracted->getEntryBlock().getFirstNonPHI()->getDebugLoc();
+    return OptimizationRemarkAnalysis(DEBUG_TYPE, "Contained", DebugLoc, LoopBB)
+    << std::to_string(NumContained);
+  });
+  
+  return false;
+}
+

llvm/lib/Transforms/IPO/LoopExtractor.cpp

 //===- LoopExtractor.cpp - Extract each loop into a new function ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // A pass wrapper around the ExtractLoop() scalar transformation to extract each
 // top-level loop into its own new function. If the loop is the ONLY loop in a
 // given function, it is not touched. This is a pass most useful for debugging
 // via bugpoint.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/LoopExtractor.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/BlockFrequencyInfo.h"
+#include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/IPO.h"
bool LoopExtractor::extractLoops(Loop::iterator From, Loop::iterator To,
   return Changed;
 }
 
 bool LoopExtractor::extractLoop(Loop *L, LoopInfo &LI, DominatorTree &DT) {
   assert(NumLoops != 0);
   Function &Func = *L->getHeader()->getParent();
   AssumptionCache *AC = LookupAssumptionCache(Func);
   CodeExtractorAnalysisCache CEAC(Func);
-  CodeExtractor Extractor(DT, *L, false, nullptr, nullptr, AC);
+  BranchProbabilityInfo BPI(Func, LI);
+  BlockFrequencyInfo BFI(Func, BPI, LI);
+  CodeExtractor Extractor(DT, *L, false, &BFI, &BPI, AC);
   if (Extractor.extractCodeRegion(CEAC)) {
     LI.erase(L);
     --NumLoops;
     ++NumExtracted;
     return true;
   }
   return false;
 }

llvm/test/Transforms/LoopExtractionAnalysis/alloca.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -passes=loop-extract-analysis -pass-remarks-analysis=loop-extract-analysis -debug-only=loop-extract-analysis -S < %s 2>&1 | FileCheck %s
+
+%struct.dummy = type { double }
+
+; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0
+
+; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0
+
+define void @alloca() {
+; CHECK-LABEL: @alloca(
+; CHECK-NEXT:  newFuncRoot:
+; CHECK-NEXT:    [[TEMP:%.*]] = alloca [[STRUCT_DUMMY:%.*]], i32 0, align 8
+; CHECK-NEXT:    br label [[HEADER:%.*]]
+; CHECK:       header:
+; CHECK-NEXT:    br label [[LATCH:%.*]]
+; CHECK:       latch:
+; CHECK-NEXT:    br label [[HEADER]]
+;
+newFuncRoot:
+  %temp = alloca %struct.dummy, i32 0, align 8
+  br label %header
+
+header:                                      ; preds = %latch, %newFuncRoot
+  br label %latch
+
+latch:                                      ; preds = %header
+  br label %header
+}
+
+attributes #0 = { argmemonly nocallback nofree nosync nounwind willreturn }

llvm/test/Transforms/LoopExtractionAnalysis/basic.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; REQUIRES: asserts
+; RUN: opt -passes=loop-extract-analysis -pass-remarks-analysis=loop-extract-analysis -debug-only=loop-extract-analysis -S < %s 2>&1 | FileCheck %s
+
+; ModuleID = 'loop-extraction/basic.cpp'
+source_filename = "loop-extraction/basic.cpp"
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+target triple = "arm64-apple-macosx12.0.0"
+
+; Function Attrs: noinline norecurse optnone ssp uwtable
+define i32 @main() #0 {
+; CHECK-LABEL: @main(
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    [[TMP2:%.*]] = alloca double, align 8
+; CHECK-NEXT:    [[TMP3:%.*]] = alloca i64, align 8
+; CHECK-NEXT:    store i32 0, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i64 0, i64* [[TMP3]], align 8
+; CHECK-NEXT:    br label [[TMP4:%.*]]
+; CHECK:       4:
+; CHECK-NEXT:    [[TMP5:%.*]] = load i64, i64* [[TMP3]], align 8
+; CHECK-NEXT:    [[TMP6:%.*]] = icmp ult i64 [[TMP5]], 100000
+; CHECK-NEXT:    br i1 [[TMP6]], label [[TMP7:%.*]], label [[TMP15:%.*]]
+; CHECK:       7:
+; CHECK-NEXT:    [[TMP8:%.*]] = call i32 @rand()
+; CHECK-NEXT:    [[TMP9:%.*]] = sitofp i32 [[TMP8]] to double
+; CHECK-NEXT:    [[TMP10:%.*]] = load double, double* [[TMP2]], align 8
+; CHECK-NEXT:    [[TMP11:%.*]] = fadd double [[TMP10]], [[TMP9]]
+; CHECK-NEXT:    store double [[TMP11]], double* [[TMP2]], align 8
+; CHECK-NEXT:    br label [[TMP12:%.*]]
+; CHECK:       12:
+; CHECK-NEXT:    [[TMP13:%.*]] = load i64, i64* [[TMP3]], align 8
+; CHECK-NEXT:    [[TMP14:%.*]] = add i64 [[TMP13]], 1
+; CHECK-NEXT:    store i64 [[TMP14]], i64* [[TMP3]], align 8
+; CHECK-NEXT:    br label [[TMP4]]
+; CHECK:       15:
+; CHECK-NEXT:    [[TMP16:%.*]] = load double, double* [[TMP2]], align 8
+; CHECK-NEXT:    [[TMP17:%.*]] = fptosi double [[TMP16]] to i32
+; CHECK-NEXT:    ret i32 [[TMP17]]
+;
+  %1 = alloca i32, align 4
+  %2 = alloca double, align 8
+  %3 = alloca i64, align 8
+  store i32 0, i32* %1, align 4
+  store i64 0, i64* %3, align 8
+  br label %4
+
+4:                                                ; preds = %12, %0
+  %5 = load i64, i64* %3, align 8
+  %6 = icmp ult i64 %5, 100000
+  br i1 %6, label %7, label %15
+
+7:                                                ; preds = %4
+  %8 = call i32 @rand()
+  %9 = sitofp i32 %8 to double
+  %10 = load double, double* %2, align 8
+  %11 = fadd double %10, %9
+  store double %11, double* %2, align 8
+  br label %12
+
+12:                                               ; preds = %7
+  %13 = load i64, i64* %3, align 8
+  %14 = add i64 %13, 1
+  store i64 %14, i64* %3, align 8
+  br label %4
+
+15:                                               ; preds = %4
+  %16 = load double, double* %2, align 8
+  %17 = fptosi double %16 to i32
+  ret i32 %17
+}
+
+declare i32 @rand() #1
+
+attributes #0 = { noinline norecurse optnone ssp uwtable "frame-pointer"="non-leaf" "min-legal-vector-width"="0" "no-trapping-math"="true" "probe-stack"="__chkstk_darwin" "stack-protector-buffer-size"="8" "target-cpu"="apple-m1" "target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz" }
+attributes #1 = { "frame-pointer"="non-leaf" "no-trapping-math"="true" "probe-stack"="__chkstk_darwin" "stack-protector-buffer-size"="8" "target-cpu"="apple-m1" "target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz" }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7, !8}
+!llvm.ident = !{!9}
+
+!0 = !{i32 2, !"SDK Version", [2 x i32] [i32 12, i32 3]}
+!1 = !{i32 1, !"wchar_size", i32 4}
+!2 = !{i32 1, !"branch-target-enforcement", i32 0}
+!3 = !{i32 1, !"sign-return-address", i32 0}
+!4 = !{i32 1, !"sign-return-address-all", i32 0}
+!5 = !{i32 1, !"sign-return-address-with-bkey", i32 0}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{i32 7, !"uwtable", i32 1}
+!8 = !{i32 7, !"frame-pointer", i32 1}
+!9 = !{!"Apple clang version 13.1.6 (clang-1316.0.21.2.5)"}

llvm/test/Transforms/LoopExtractionAnalysis/complex.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; REQUIRES: asserts
+; RUN: opt -passes=loop-extract-analysis -pass-remarks-analysis=loop-extract-analysis -debug-only=loop-extract-analysis -S < %s 2>&1 | FileCheck %s
+
+; ModuleID = 'loop-extraction/complex.cpp'
+source_filename = "loop-extraction/complex.cpp"
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+target triple = "arm64-apple-macosx12.0.0"
+
+; Function Attrs: noinline optnone ssp uwtable
+define double @_Z14other_functionv() #0 {
+; CHECK-LABEL: @_Z14other_functionv(
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca double, align 8
+; CHECK-NEXT:    [[TMP2:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    store double 0.000000e+00, double* [[TMP1]], align 8
+; CHECK-NEXT:    br label [[TMP3:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    [[TMP4:%.*]] = load double, double* [[TMP1]], align 8
+; CHECK-NEXT:    [[TMP5:%.*]] = fcmp olt double [[TMP4]], 1.000000e+03
+; CHECK-NEXT:    br i1 [[TMP5]], label [[TMP6:%.*]], label [[TMP21:%.*]]
+; CHECK:       6:
+; CHECK-NEXT:    store i32 0, i32* [[TMP2]], align 4
+; CHECK-NEXT:    br label [[TMP7:%.*]]
+; CHECK:       7:
+; CHECK-NEXT:    [[TMP8:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[TMP9:%.*]] = icmp slt i32 [[TMP8]], 1000
+; CHECK-NEXT:    br i1 [[TMP9]], label [[TMP10:%.*]], label [[TMP18:%.*]]
+; CHECK:       10:
+; CHECK-NEXT:    [[TMP11:%.*]] = call i32 @rand()
+; CHECK-NEXT:    [[TMP12:%.*]] = sitofp i32 [[TMP11]] to double
+; CHECK-NEXT:    [[TMP13:%.*]] = load double, double* [[TMP1]], align 8
+; CHECK-NEXT:    [[TMP14:%.*]] = fadd double [[TMP13]], [[TMP12]]
+; CHECK-NEXT:    store double [[TMP14]], double* [[TMP1]], align 8
+; CHECK-NEXT:    br label [[TMP15:%.*]]
+; CHECK:       15:
+; CHECK-NEXT:    [[TMP16:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[TMP17:%.*]] = add nsw i32 [[TMP16]], 1
+; CHECK-NEXT:    store i32 [[TMP17]], i32* [[TMP2]], align 4
+; CHECK-NEXT:    br label [[TMP7]]
+; CHECK:       18:
+; CHECK-NEXT:    [[TMP19:%.*]] = load double, double* [[TMP1]], align 8
+; CHECK-NEXT:    [[TMP20:%.*]] = fadd double [[TMP19]], 1.000000e+00
+; CHECK-NEXT:    store double [[TMP20]], double* [[TMP1]], align 8
+; CHECK-NEXT:    br label [[TMP3]]
+; CHECK:       21:
+; CHECK-NEXT:    [[TMP22:%.*]] = load double, double* [[TMP1]], align 8
+; CHECK-NEXT:    ret double [[TMP22]]
+;
+  %1 = alloca double, align 8
+  %2 = alloca i32, align 4
+  store double 0.000000e+00, double* %1, align 8
+  br label %3
+
+3:                                                ; preds = %18, %0
+  %4 = load double, double* %1, align 8
+  %5 = fcmp olt double %4, 1.000000e+03
+  br i1 %5, label %6, label %21
+
+6:                                                ; preds = %3
+  store i32 0, i32* %2, align 4
+  br label %7
+
+7:                                                ; preds = %15, %6
+  %8 = load i32, i32* %2, align 4
+  %9 = icmp slt i32 %8, 1000
+  br i1 %9, label %10, label %18
+
+10:                                               ; preds = %7
+  %11 = call i32 @rand()
+  %12 = sitofp i32 %11 to double
+  %13 = load double, double* %1, align 8
+  %14 = fadd double %13, %12
+  store double %14, double* %1, align 8
+  br label %15
+
+15:                                               ; preds = %10
+  %16 = load i32, i32* %2, align 4
+  %17 = add nsw i32 %16, 1
+  store i32 %17, i32* %2, align 4
+  br label %7
+
+18:                                               ; preds = %7
+  %19 = load double, double* %1, align 8
+  %20 = fadd double %19, 1.000000e+00
+  store double %20, double* %1, align 8
+  br label %3
+
+21:                                               ; preds = %3
+  %22 = load double, double* %1, align 8
+  ret double %22
+}
+
+declare i32 @rand() #1
+
+; Function Attrs: noinline norecurse optnone ssp uwtable
+define i32 @main() #2 {
+; CHECK-LABEL: @main(
+; CHECK-NEXT:    [[TMP1:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    [[TMP2:%.*]] = alloca double, align 8
+; CHECK-NEXT:    [[TMP3:%.*]] = alloca i64, align 8
+; CHECK-NEXT:    [[TMP4:%.*]] = alloca i64, align 8
+; CHECK-NEXT:    store i32 0, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i64 0, i64* [[TMP3]], align 8
+; CHECK-NEXT:    br label [[TMP5:%.*]]
+; CHECK:       5:
+; CHECK-NEXT:    [[TMP6:%.*]] = load i64, i64* [[TMP3]], align 8
+; CHECK-NEXT:    [[TMP7:%.*]] = icmp ult i64 [[TMP6]], 1000
+; CHECK-NEXT:    br i1 [[TMP7]], label [[TMP8:%.*]], label [[TMP35:%.*]]
+; CHECK:       8:
+; CHECK-NEXT:    [[TMP9:%.*]] = load i64, i64* [[TMP3]], align 8
+; CHECK-NEXT:    store i64 [[TMP9]], i64* [[TMP4]], align 8
+; CHECK-NEXT:    br label [[TMP10:%.*]]
+; CHECK:       10:
+; CHECK-NEXT:    [[TMP11:%.*]] = load i64, i64* [[TMP4]], align 8
+; CHECK-NEXT:    [[TMP12:%.*]] = icmp ult i64 [[TMP11]], 1000
+; CHECK-NEXT:    br i1 [[TMP12]], label [[TMP13:%.*]], label [[TMP24:%.*]]
+; CHECK:       13:
+; CHECK-NEXT:    [[TMP14:%.*]] = call i32 @rand()
+; CHECK-NEXT:    [[TMP15:%.*]] = sext i32 [[TMP14]] to i64
+; CHECK-NEXT:    [[TMP16:%.*]] = load i64, i64* [[TMP4]], align 8
+; CHECK-NEXT:    [[TMP17:%.*]] = mul i64 [[TMP15]], [[TMP16]]
+; CHECK-NEXT:    [[TMP18:%.*]] = uitofp i64 [[TMP17]] to double
+; CHECK-NEXT:    [[TMP19:%.*]] = load double, double* [[TMP2]], align 8
+; CHECK-NEXT:    [[TMP20:%.*]] = fadd double [[TMP19]], [[TMP18]]
+; CHECK-NEXT:    store double [[TMP20]], double* [[TMP2]], align 8
+; CHECK-NEXT:    br label [[TMP21:%.*]]
+; CHECK:       21:
+; CHECK-NEXT:    [[TMP22:%.*]] = load i64, i64* [[TMP4]], align 8
+; CHECK-NEXT:    [[TMP23:%.*]] = add i64 [[TMP22]], 1
+; CHECK-NEXT:    store i64 [[TMP23]], i64* [[TMP4]], align 8
+; CHECK-NEXT:    br label [[TMP10]]
+; CHECK:       24:
+; CHECK-NEXT:    [[TMP25:%.*]] = call i32 @rand()
+; CHECK-NEXT:    [[TMP26:%.*]] = sext i32 [[TMP25]] to i64
+; CHECK-NEXT:    [[TMP27:%.*]] = load i64, i64* [[TMP3]], align 8
+; CHECK-NEXT:    [[TMP28:%.*]] = mul i64 [[TMP26]], [[TMP27]]
+; CHECK-NEXT:    [[TMP29:%.*]] = uitofp i64 [[TMP28]] to double
+; CHECK-NEXT:    [[TMP30:%.*]] = load double, double* [[TMP2]], align 8
+; CHECK-NEXT:    [[TMP31:%.*]] = fadd double [[TMP30]], [[TMP29]]
+; CHECK-NEXT:    store double [[TMP31]], double* [[TMP2]], align 8
+; CHECK-NEXT:    br label [[TMP32:%.*]]
+; CHECK:       32:
+; CHECK-NEXT:    [[TMP33:%.*]] = load i64, i64* [[TMP3]], align 8
+; CHECK-NEXT:    [[TMP34:%.*]] = add i64 [[TMP33]], 1
+; CHECK-NEXT:    store i64 [[TMP34]], i64* [[TMP3]], align 8
+; CHECK-NEXT:    br label [[TMP5]]
+; CHECK:       35:
+; CHECK-NEXT:    [[TMP36:%.*]] = call double @_Z14other_functionv()
+; CHECK-NEXT:    [[TMP37:%.*]] = load double, double* [[TMP2]], align 8
+; CHECK-NEXT:    [[TMP38:%.*]] = fadd double [[TMP37]], [[TMP36]]
+; CHECK-NEXT:    store double [[TMP38]], double* [[TMP2]], align 8
+; CHECK-NEXT:    [[TMP39:%.*]] = load double, double* [[TMP2]], align 8
+; CHECK-NEXT:    [[TMP40:%.*]] = fptosi double [[TMP39]] to i32
+; CHECK-NEXT:    ret i32 [[TMP40]]
+;
+  %1 = alloca i32, align 4
+  %2 = alloca double, align 8
+  %3 = alloca i64, align 8
+  %4 = alloca i64, align 8
+  store i32 0, i32* %1, align 4
+  store i64 0, i64* %3, align 8
+  br label %5
+
+5:                                                ; preds = %32, %0
+  %6 = load i64, i64* %3, align 8
+  %7 = icmp ult i64 %6, 1000
+  br i1 %7, label %8, label %35
+
+8:                                                ; preds = %5
+  %9 = load i64, i64* %3, align 8
+  store i64 %9, i64* %4, align 8
+  br label %10
+
+10:                                               ; preds = %21, %8
+  %11 = load i64, i64* %4, align 8
+  %12 = icmp ult i64 %11, 1000
+  br i1 %12, label %13, label %24
+
+13:                                               ; preds = %10
+  %14 = call i32 @rand()
+  %15 = sext i32 %14 to i64
+  %16 = load i64, i64* %4, align 8
+  %17 = mul i64 %15, %16
+  %18 = uitofp i64 %17 to double
+  %19 = load double, double* %2, align 8
+  %20 = fadd double %19, %18
+  store double %20, double* %2, align 8
+  br label %21
+
+21:                                               ; preds = %13
+  %22 = load i64, i64* %4, align 8
+  %23 = add i64 %22, 1
+  store i64 %23, i64* %4, align 8
+  br label %10
+
+24:                                               ; preds = %10
+  %25 = call i32 @rand()
+  %26 = sext i32 %25 to i64
+  %27 = load i64, i64* %3, align 8
+  %28 = mul i64 %26, %27
+  %29 = uitofp i64 %28 to double
+  %30 = load double, double* %2, align 8
+  %31 = fadd double %30, %29
+  store double %31, double* %2, align 8
+  br label %32
+
+32:                                               ; preds = %24
+  %33 = load i64, i64* %3, align 8
+  %34 = add i64 %33, 1
+  store i64 %34, i64* %3, align 8
+  br label %5
+
+35:                                               ; preds = %5
+  %36 = call double @_Z14other_functionv()
+  %37 = load double, double* %2, align 8
+  %38 = fadd double %37, %36
+  store double %38, double* %2, align 8
+  %39 = load double, double* %2, align 8
+  %40 = fptosi double %39 to i32
+  ret i32 %40
+}
+
+attributes #0 = { noinline optnone ssp uwtable "frame-pointer"="non-leaf" "min-legal-vector-width"="0" "no-trapping-math"="true" "probe-stack"="__chkstk_darwin" "stack-protector-buffer-size"="8" "target-cpu"="apple-m1" "target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz" }
+attributes #1 = { "frame-pointer"="non-leaf" "no-trapping-math"="true" "probe-stack"="__chkstk_darwin" "stack-protector-buffer-size"="8" "target-cpu"="apple-m1" "target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz" }
+attributes #2 = { noinline norecurse optnone ssp uwtable "frame-pointer"="non-leaf" "min-legal-vector-width"="0" "no-trapping-math"="true" "probe-stack"="__chkstk_darwin" "stack-protector-buffer-size"="8" "target-cpu"="apple-m1" "target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz" }
+
+!llvm.module.flags = !{!0, !1, !2, !3, !4, !5, !6, !7, !8}
+!llvm.ident = !{!9}
+
+!0 = !{i32 2, !"SDK Version", [2 x i32] [i32 12, i32 3]}
+!1 = !{i32 1, !"wchar_size", i32 4}
+!2 = !{i32 1, !"branch-target-enforcement", i32 0}
+!3 = !{i32 1, !"sign-return-address", i32 0}
+!4 = !{i32 1, !"sign-return-address-all", i32 0}
+!5 = !{i32 1, !"sign-return-address-with-bkey", i32 0}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{i32 7, !"uwtable", i32 1}
+!8 = !{i32 7, !"frame-pointer", i32 1}
+!9 = !{!"Apple clang version 13.1.6 (clang-1316.0.21.2.5)"}

llvm/test/lit.cfg.py

tools = [
     ToolSubst('%ocamlc', ocamlc_command, unresolved='ignore'),
     ToolSubst('%ocamlopt', ocamlopt_command, unresolved='ignore'),
     ToolSubst('%opt-viewer', opt_viewer_cmd),
     ToolSubst('%llvm-objcopy', FindTool('llvm-objcopy')),
     ToolSubst('%llvm-strip', FindTool('llvm-strip')),
     ToolSubst('%llvm-install-name-tool', FindTool('llvm-install-name-tool')),
     ToolSubst('%llvm-bitcode-strip', FindTool('llvm-bitcode-strip')),
     ToolSubst('%split-file', FindTool('split-file')),
+    ToolSubst('%loop-analyzer', FindTool('loop-analyzer')),
 ]
 
 # FIXME: Why do we have both `lli` and `%lli` that do slightly different things?
 tools.extend([
     'dsymutil', 'lli', 'lli-child-target', 'llvm-ar', 'llvm-as',
     'llvm-addr2line', 'llvm-bcanalyzer', 'llvm-bitcode-strip', 'llvm-config',
     'llvm-cov', 'llvm-cxxdump', 'llvm-cvtres', 'llvm-debuginfod-find', 'llvm-debuginfod',
     'llvm-diff', 'llvm-dis', 'llvm-dwarfdump', 'llvm-dwarfutil', 'llvm-dlltool',

llvm/test/tools/loop-analyzer/Outputs/basic.result.txt

+Loops:
+_______________________
+Name: main.for.body
+IR: 
+; Function Attrs: mustprogress norecurse ssp uwtable
+define hidden void @main.for.body(ptr %sum.1.lcssa.out) #1 !dbg !13 {
+newFuncRoot:
+  br label %for.body, !dbg !17
+
+for.body:                                         ; preds = %for.cond.cleanup3, %newFuncRoot
+  %i.021 = phi i64 [ 0, %newFuncRoot ], [ %inc9, %for.cond.cleanup3 ]
+  %sum.020 = phi double [ 0.000000e+00, %newFuncRoot ], [ %sum.1.lcssa, %for.cond.cleanup3 ]
+  %call = tail call i32 @rand(), !dbg !17
+  %conv = sitofp i32 %call to double, !dbg !17
+  %add = fadd double %sum.020, %conv, !dbg !18
+  %cmp217.not = icmp eq i64 %i.021, 0, !dbg !19
+  br i1 %cmp217.not, label %for.cond.cleanup3, label %for.body4.preheader, !dbg !20
+
+for.body4:                                        ; preds = %for.body4.preheader, %for.body4
+  %j.019 = phi i64 [ %inc, %for.body4 ], [ 0, %for.body4.preheader ]
+  %sum.118 = phi double [ %add7, %for.body4 ], [ %add, %for.body4.preheader ]
+  %call5 = tail call i32 @rand(), !dbg !21
+  %conv6 = sitofp i32 %call5 to double, !dbg !21
+  %add7 = fadd double %sum.118, %conv6, !dbg !22
+  %inc = add nuw nsw i64 %j.019, 1, !dbg !23
+  %exitcond.not = icmp eq i64 %inc, %i.021, !dbg !19
+  br i1 %exitcond.not, label %for.cond.cleanup3.loopexit, label %for.body4, !dbg !20, !llvm.loop !24
+
+for.cond.cleanup3:                                ; preds = %for.cond.cleanup3.loopexit, %for.body
+  %sum.1.lcssa = phi double [ %add, %for.body ], [ %add7, %for.cond.cleanup3.loopexit ], !dbg !27
+  store double %sum.1.lcssa, ptr %sum.1.lcssa.out, align 8
+  %inc9 = add nuw nsw i64 %i.021, 1, !dbg !28
+  %exitcond22.not = icmp eq i64 %inc9, 2048, !dbg !29
+  br i1 %exitcond22.not, label %for.cond.cleanup.exitStub, label %for.body, !dbg !30, !llvm.loop !31
+
+for.body4.preheader:                              ; preds = %for.body
+  br label %for.body4, !dbg !20
+
+for.cond.cleanup3.loopexit:                       ; preds = %for.body4
+  br label %for.cond.cleanup3, !dbg !28
+
+for.cond.cleanup.exitStub:                        ; preds = %for.cond.cleanup3
+  ret void
+}
+
+# Exiting Nodes: 1
+Known Bounds: true
+Vectorized: false
+
+_______________
+Summary Stats: 
+# of module dumps: 1
+
+Extracted: 1
+Contained in extracted loops: 0
+
+Total known bounds: 1
+Total Vectorized: 0
+

llvm/test/tools/loop-analyzer/Outputs/complex.result.txt

+Loops:
+_______________________
+Name: _Z5otherv.for.body
+IR: 
+; Function Attrs: mustprogress ssp uwtable
+define hidden void @_Z5otherv.for.body(ptr %sum.0.lcssa.ce.out) #1 !dbg !13 {
+newFuncRoot:
+  br label %for.body, !dbg !17
+
+for.body:                                         ; preds = %for.cond.cleanup6, %newFuncRoot
+  %j.028 = phi i64 [ 0, %newFuncRoot ], [ %inc14, %for.cond.cleanup6 ]
+  %sum.027 = phi double [ 0.000000e+00, %newFuncRoot ], [ %sum.1.lcssa, %for.cond.cleanup6 ]
+  %call = tail call i32 @rand(), !dbg !17
+  %mul = mul nsw i32 %call, 10, !dbg !18
+  %conv = sext i32 %mul to i64, !dbg !17
+  %cmp1 = icmp eq i64 %j.028, %conv, !dbg !19
+  br i1 %cmp1, label %cleanup.split, label %if.end, !dbg !20
+
+if.end:                                           ; preds = %for.body
+  %call2 = tail call i32 @rand(), !dbg !21
+  %conv3 = sitofp i32 %call2 to double, !dbg !21
+  %add = fadd double %sum.027, %conv3, !dbg !22
+  %cmp524.not = icmp eq i64 %j.028, 0, !dbg !23
+  br i1 %cmp524.not, label %for.cond.cleanup6, label %for.body7.preheader, !dbg !24
+
+for.body7:                                        ; preds = %for.body7.preheader, %for.body7
+  %i.026 = phi i64 [ %inc, %for.body7 ], [ 0, %for.body7.preheader ]
+  %sum.125 = phi double [ %add12, %for.body7 ], [ %add, %for.body7.preheader ]
+  %call8 = tail call i32 @rand(), !dbg !25
+  %conv9 = sext i32 %call8 to i64, !dbg !25
+  %mul10 = mul i64 %i.026, %conv9, !dbg !26
+  %conv11 = uitofp i64 %mul10 to double, !dbg !25
+  %add12 = fadd double %sum.125, %conv11, !dbg !27
+  %inc = add nuw nsw i64 %i.026, 1, !dbg !28
+  %exitcond.not = icmp eq i64 %inc, %j.028, !dbg !23
+  br i1 %exitcond.not, label %for.cond.cleanup6.loopexit, label %for.body7, !dbg !24, !llvm.loop !29
+
+for.cond.cleanup6:                                ; preds = %for.cond.cleanup6.loopexit, %if.end
+  %sum.1.lcssa = phi double [ %add, %if.end ], [ %add12, %for.cond.cleanup6.loopexit ], !dbg !32
+  %inc14 = add nuw nsw i64 %j.028, 1, !dbg !33
+  %exitcond29.not = icmp eq i64 %inc14, 10000, !dbg !34
+  br i1 %exitcond29.not, label %cleanup.split, label %for.body, !dbg !35, !llvm.loop !36
+
+for.body7.preheader:                              ; preds = %if.end
+  br label %for.body7, !dbg !24
+
+for.cond.cleanup6.loopexit:                       ; preds = %for.body7
+  br label %for.cond.cleanup6, !dbg !33
+
+cleanup.split:                                    ; preds = %for.cond.cleanup6, %for.body
+  %sum.0.lcssa.ce = phi double [ %sum.027, %for.body ], [ %sum.1.lcssa, %for.cond.cleanup6 ]
+  store double %sum.0.lcssa.ce, ptr %sum.0.lcssa.ce.out, align 8
+  br label %cleanup.exitStub
+
+cleanup.exitStub:                                 ; preds = %cleanup.split
+  ret void
+}
+
+# Exiting Nodes: 2
+Known Bounds: false
+Vectorized: false
+_______________________
+Name: _Z4testPiS_S_.for.body
+IR: 
+; Function Attrs: mustprogress nofree norecurse nounwind ssp uwtable
+define hidden void @_Z4testPiS_S_.for.body(ptr %a, ptr %b, ptr %c) #2 !dbg !38 {
+newFuncRoot:
+  br label %for.body, !dbg !39
+
+for.body:                                         ; preds = %for.body, %newFuncRoot
+  %i.07 = phi i64 [ 0, %newFuncRoot ], [ %inc, %for.body ]
+  %arrayidx = getelementptr inbounds i32, ptr %a, i64 %i.07, !dbg !39
+  %0 = load i32, ptr %arrayidx, align 4, !dbg !39, !tbaa !40
+  %arrayidx1 = getelementptr inbounds i32, ptr %b, i64 %i.07, !dbg !44
+  %1 = load i32, ptr %arrayidx1, align 4, !dbg !44, !tbaa !40
+  %add = add nsw i32 %1, %0, !dbg !45
+  %arrayidx2 = getelementptr inbounds i32, ptr %c, i64 %i.07, !dbg !46
+  store i32 %add, ptr %arrayidx2, align 4, !dbg !47, !tbaa !40
+  %inc = add nuw nsw i64 %i.07, 1, !dbg !48
+  %exitcond.not = icmp eq i64 %inc, 256, !dbg !49
+  br i1 %exitcond.not, label %for.cond.cleanup.exitStub, label %for.body, !dbg !50, !llvm.loop !51
+
+for.cond.cleanup.exitStub:                        ; preds = %for.body
+  ret void
+}
+
+# Exiting Nodes: 1
+Known Bounds: true
+Vectorized: true
+_______________________
+Name: _Z4testPfS_S_S_S_.for.body
+IR: 
+; Function Attrs: mustprogress nofree norecurse nounwind ssp uwtable
+define hidden void @_Z4testPfS_S_S_S_.for.body(ptr %B, ptr %C, ptr %D, ptr %E, ptr %A) #2 !dbg !55 {
+newFuncRoot:
+  br label %for.body, !dbg !56
+
+for.body:                                         ; preds = %for.body, %newFuncRoot
+  %indvars.iv = phi i64 [ 0, %newFuncRoot ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds float, ptr %B, i64 %indvars.iv, !dbg !56
+  %0 = load float, ptr %arrayidx, align 4, !dbg !56, !tbaa !57
+  %arrayidx2 = getelementptr inbounds float, ptr %C, i64 %indvars.iv, !dbg !59
+  %1 = load float, ptr %arrayidx2, align 4, !dbg !59, !tbaa !57
+  %add = fadd float %0, %1, !dbg !60
+  %arrayidx4 = getelementptr inbounds float, ptr %D, i64 %indvars.iv, !dbg !61
+  %2 = load float, ptr %arrayidx4, align 4, !dbg !61, !tbaa !57
+  %add5 = fadd float %add, %2, !dbg !62
+  %arrayidx7 = getelementptr inbounds float, ptr %E, i64 %indvars.iv, !dbg !63
+  %3 = load float, ptr %arrayidx7, align 4, !dbg !63, !tbaa !57
+  %add8 = fadd float %add5, %3, !dbg !64
+  %arrayidx10 = getelementptr inbounds float, ptr %A, i64 %indvars.iv, !dbg !65
+  store float %add8, ptr %arrayidx10, align 4, !dbg !66, !tbaa !57
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1, !dbg !67
+  %exitcond.not = icmp eq i64 %indvars.iv.next, 256, !dbg !68
+  br i1 %exitcond.not, label %for.cond.cleanup.exitStub, label %for.body, !dbg !69, !llvm.loop !70
+
+for.cond.cleanup.exitStub:                        ; preds = %for.body
+  ret void
+}
+
+# Exiting Nodes: 1
+Known Bounds: true
+Vectorized: true
+_______________________
+Name: main.for.body.i
+IR: 
+; Function Attrs: mustprogress norecurse ssp uwtable
+define hidden void @main.for.body.i() #3 !dbg !73 {
+newFuncRoot:
+  br label %for.body.i, !dbg !74
+
+for.body.i:                                       ; preds = %for.cond.cleanup6.i, %newFuncRoot
+  %j.028.i = phi i64 [ %inc14.i, %for.cond.cleanup6.i ], [ 0, %newFuncRoot ]
+  %call.i = tail call i32 @rand(), !dbg !74
+  %mul.i = mul nsw i32 %call.i, 10, !dbg !75
+  %conv.i = sext i32 %mul.i to i64, !dbg !74
+  %cmp1.i = icmp eq i64 %j.028.i, %conv.i, !dbg !76
+  br i1 %cmp1.i, label %_Z5otherv.exit.exitStub, label %if.end.i, !dbg !77
+
+if.end.i:                                         ; preds = %for.body.i
+  %call2.i = tail call i32 @rand(), !dbg !78
+  %cmp524.not.i = icmp eq i64 %j.028.i, 0, !dbg !79
+  br i1 %cmp524.not.i, label %for.cond.cleanup6.i, label %for.body7.i.preheader, !dbg !80
+
+for.body7.i:                                      ; preds = %for.body7.i.preheader, %for.body7.i
+  %i.026.i = phi i64 [ %inc.i, %for.body7.i ], [ 0, %for.body7.i.preheader ]
+  %call8.i = tail call i32 @rand(), !dbg !81
+  %inc.i = add nuw nsw i64 %i.026.i, 1, !dbg !82
+  %exitcond.not.i = icmp eq i64 %inc.i, %j.028.i, !dbg !79
+  br i1 %exitcond.not.i, label %for.cond.cleanup6.i.loopexit, label %for.body7.i, !dbg !80, !llvm.loop !83
+
+for.cond.cleanup6.i:                              ; preds = %for.cond.cleanup6.i.loopexit, %if.end.i
+  %inc14.i = add nuw nsw i64 %j.028.i, 1, !dbg !85
+  %exitcond29.not.i = icmp eq i64 %inc14.i, 10000, !dbg !86
+  br i1 %exitcond29.not.i, label %_Z5otherv.exit.exitStub, label %for.body.i, !dbg !87, !llvm.loop !88
+
+for.body7.i.preheader:                            ; preds = %if.end.i
+  br label %for.body7.i, !dbg !80
+
+for.cond.cleanup6.i.loopexit:                     ; preds = %for.body7.i
+  br label %for.cond.cleanup6.i, !dbg !85
+
+_Z5otherv.exit.exitStub:                          ; preds = %for.cond.cleanup6.i, %for.body.i
+  ret void
+}
+
+# Exiting Nodes: 2
+Known Bounds: false
+Vectorized: false
+_______________________
+Name: main.for.body
+IR: 
+; Function Attrs: mustprogress norecurse ssp uwtable
+define hidden void @main.for.body(ptr %add.out) #3 !dbg !90 {
+newFuncRoot:
+  br label %for.body, !dbg !91
+
+for.body:                                         ; preds = %for.body, %newFuncRoot
+  %i.012 = phi i64 [ 0, %newFuncRoot ], [ %inc, %for.body ]
+  %sum.011 = phi double [ 0.000000e+00, %newFuncRoot ], [ %add, %for.body ]
+  %call = tail call i32 @rand(), !dbg !91
+  %conv = sitofp i32 %call to double, !dbg !91
+  %add = fadd double %sum.011, %conv, !dbg !92
+  store double %add, ptr %add.out, align 8
+  %inc = add nuw nsw i64 %i.012, 1, !dbg !93
+  %exitcond.not = icmp eq i64 %inc, 100000, !dbg !94
+  br i1 %exitcond.not, label %for.body.i.preheader.exitStub, label %for.body, !dbg !95, !llvm.loop !96
+
+for.body.i.preheader.exitStub:                    ; preds = %for.body
+  ret void
+}
+
+# Exiting Nodes: 1
+Known Bounds: true
+Vectorized: false
+
+_______________
+Summary Stats: 
+# of module dumps: 1
+
+Extracted: 5
+Contained in extracted loops: 0
+
+Total known bounds: 3
+Total Vectorized: 2
+

llvm/test/tools/loop-analyzer/basic.test

+# We simply compare the actual output against the expected output
+# This is a simple test on a couple loops
+
+RUN: %loop-analyzer %p/Inputs/basic.dwarf /dev/null 2> %p/temp.txt
+RUN: diff %p/temp.txt %p/Outputs/basic.result.txt

llvm/test/tools/loop-analyzer/complex.test

+# We simply compare the actual output against the expected output
+# This is a simple test on a couple loops
+
+RUN: %loop-analyzer %p/Inputs/complex.dwarf /dev/null 2> %p/temp.txt
+RUN: diff %p/temp.txt %p/Outputs/complex.result.txt

llvm/tools/loop-analyzer/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Core
+  IRReader
+  Support
+  Analysis
+  TransformUtils
+  Vectorize
+  Target
+  AllTargetsAsmParsers
+  AllTargetsCodeGens
+  AllTargetsDescs
+  AllTargetsInfos
+  AllTargetsDisassemblers
+)
+
+add_llvm_tool(loop-analyzer
+  loop-analyzer.cpp
+
+  DEPENDS
+  intrinsics_gen
+  SUPPORT_PLUGINS
+  )
 No newline at end of file

llvm/tools/loop-analyzer/README.md

+# Loop Analyzer
+## Setup
+Build using `ninja clang loop-analyzer`
+## CL Usage
+1. Compile with clang, turn on profile training
+```
+clang++ -
+```
+1. 
+
+2. Compile with clang, with profiling information
+```
+clang++ -fsave-optimization-record=bitstream -foptimization-record-passes=loop-extract-analysis [other-flags] <filename> -o <output_filename>
+```
+2. Extract Remarks
+```
+dsymutil <output_filename>
+```
+3. Loop Analysis
+```
+loop-analyzer <output_filename>.dSYM/Contents/Resources/Remarks/<output_filename>
+```
+
+## Program Description
+
+When we run the `loop-extract-analysis` pass, we are emiting a remark for each loop in the program. Our `loop-analyzer`
 No newline at end of file

llvm/tools/loop-analyzer/loop-analyzer.cpp

+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Bitcode/BitcodeReader.h"
+#include "llvm/Analysis/BlockFrequencyInfo.h"
+#include "llvm/Analysis/BranchProbabilityInfo.h"
+
+#include "llvm/Remarks/Remark.h"
+#include "llvm/Remarks/RemarkParser.h"
+
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/WithColor.h"
+#include "llvm/Support/TargetSelect.h"
+
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/DiagnosticPrinter.h"
+
+#include "llvm/Linker/Linker.h"
+
+#include "llvm/Transforms/Vectorize/LoopVectorize.h"
+#include "llvm/Transforms/Vectorize.h"
+
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/MC/SubtargetFeature.h"
+
+#include "llvm/IRReader/IRReader.h"
+
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Target/CodeGenCWrappers.h"
+
+#include <iostream>
+#include <fstream>
+#include <cstdio>
+#include <vector>
+
+#include "llvm/Remarks/Remark.h"
+
+using namespace llvm;
+
+static cl::OptionCategory SizeDiffCategory("llvm-remark-size-diff options");
+static cl::opt<std::string> InputFileName(cl::Positional, cl::Required,
+                                           cl::cat(SizeDiffCategory),
+                                           cl::desc("remarks_file"));
+
+static cl::opt<std::string> OutputFileName(cl::Positional, cl::Required,
+                                           cl::cat(SizeDiffCategory),
+                                           cl::desc("output remark file"));
+
+static int Extracted, NotExtracted, NotSimplified, Contained, Dumps, NumVectorized, NumDeterminableBounds;
+
+
+
+// static int OptRemarks, MissedRemarks, FailedRemarks, AnalysisRemarks;
+
+static enum VectorizationResult {
+  Success,
+  NotProfitable,
+  ContainsCallInstruction,
+  Other
+} VectorizeRes;
+
+// struct to contain all information about a loop
+typedef struct LoopDetails {
+  Function *F;
+  VectorizationResult VecRes;
+  bool KnownBounds;
+  unsigned ExitNodes;
+  unsigned Hotness;
+} LoopDetails;
+
+// Summary of vectorization results
+typedef struct VectorizationSummary {
+  unsigned NumSuccess;
+  unsigned NumNotProfitable;
+  unsigned NumContainsCallInstruction;
+  unsigned NumOther;
+  
+  VectorizationSummary() :  NumSuccess(0), NumNotProfitable(0),
+                            NumContainsCallInstruction(0),
+                            NumOther(0) { }
+} VectorizationSummary;
+
+static VectorizationSummary VectorizeCounter;
+
+class MyDiagnosticHandler final : public DiagnosticHandler {
+public:
+  MyDiagnosticHandler() : VectorizePassName("LoopVectorize") { }
+  
+  bool handleDiagnostics(const DiagnosticInfo &DI) override {
+    std::string Msg; raw_string_ostream RSO(Msg);
+    DiagnosticPrinterRawOStream DP(RSO);
+    DI.print(DP);
+    
+    const DiagnosticInfoOptimizationBase *DIOB =
+      cast<DiagnosticInfoOptimizationBase>(&DI);
+    if (DIOB) {
+      const Optional<uint64_t> Hotness = DIOB->getHotness();
+      if (Hotness)
+        dbgs() << "Hotness: " << Hotness.value() << "\n";
+    }
+    
+    std::string ToMatch;
+    switch (DI.getKind()) {
+      case DK_OptimizationRemarkAnalysis:
+        ToMatch = "call instruction cannot be vectorized";
+        if (Msg.find(ToMatch) != std::string::npos) {
+          VectorizeRes = VectorizationResult::ContainsCallInstruction;
+          VectorizeCounter.NumContainsCallInstruction++;
+          return true;
+        } else {
+          VectorizeRes = VectorizationResult::Other;
+          VectorizeCounter.NumOther++;
+          return true;
+        }
+        // This is where we would add more checks
+        
+      case DK_OptimizationRemark:
+        ToMatch = "vectorized loop";
+        if (Msg.find(ToMatch) != std::string::npos) {
+          VectorizeRes = VectorizationResult::Success;
+          VectorizeCounter.NumSuccess++;
+        }
+        return true;
+    }
+    return false;
+  }
+
+  bool isAnalysisRemarkEnabled(StringRef PassName) const override {
+    return VectorizePassName.equals(PassName);
+  }
+  bool isMissedOptRemarkEnabled(StringRef PassName) const override {
+    return VectorizePassName.equals(PassName);
+  }
+  bool isPassedOptRemarkEnabled(StringRef PassName) const override {
+    return VectorizePassName.equals(PassName);
+  }
+
+  bool isAnyRemarkEnabled() const override {
+    return true;
+  }
+  
+private:
+  StringRef VectorizePassName;
+};
+
+
+legacy::FunctionPassManager createFPM(Module &M) {
+  legacy::FunctionPassManager FPM(&M);
+
+  std::string Msg;
+  const Target *T = TargetRegistry::lookupTarget(M.getTargetTriple(), Msg);
+  SubtargetFeatures Features;
+  Features.getDefaultSubtargetFeatures(Triple(M.getTargetTriple()));
+
+  const TargetMachine *TM = T->createTargetMachine(M.getTargetTriple(), "", Features.getString(), TargetOptions(), Reloc::Static, M.getCodeModel(), CodeGenOpt::Default);
+
+  FPM.add(createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
+  FPM.add(createLoopVectorizePass());
+
+  return FPM;
+}
+
+void printLoopSummaries(Module &M) {
+  auto FPM = createFPM(M);
+  dbgs() << "Loops:\n";
+  for (Function &F : M) {
+    if (F.empty())
+      continue;
+    
+    DominatorTree DT;
+    DT.recalculate(F);
+    
+    LoopInfo LI;
+    LI.analyze(DT);
+    
+    const Loop *L = *LI.begin();
+    
+    if (!L) {
+      errs() << "Extracted function didn't have a loop?\n";
+      exit(1);
+    }
+    
+    dbgs() << "_______________________\n";
+    dbgs() << "Name: " << F.getName() << "\n";
+    dbgs() << "IR: \n";
+    F.dump();
+    
+    SmallVector<BasicBlock*, 16> ExitingBlocks;
+    L->getExitingBlocks(ExitingBlocks);
+    dbgs() << "# Exiting Nodes: " << ExitingBlocks.size() << "\n";
+    
+    
+    TargetLibraryInfoImpl TLII;
+    TargetLibraryInfo TLI(TLII);
+    AssumptionCache AC(F);
+    ScalarEvolution SE(F, TLI, AC, DT, LI);
+    if (isa<SCEVCouldNotCompute>(SE.getBackedgeTakenCount(L))) {
+      dbgs() << "Known Bounds: false\n";
+    } else {
+      dbgs() << "Known Bounds: true\n";
+      NumDeterminableBounds++;
+    }
+    
+    FPM.run(F);
+    dbgs() << "Vectorized: ";
+    switch (VectorizeRes) {
+      case VectorizationResult::Success:
+        dbgs() << "true\n";
+        break;
+        
+      case VectorizationResult::ContainsCallInstruction:
+        dbgs() << "false: contains call instruction\n";
+        break;
+        
+      default:
+        dbgs() << "false\n";
+        break;
+    }
+  }
+}
+
+LLVMContext Context;
+std::unique_ptr<Module> ModulePointer;
+//std::vector<std::unique_ptr<Module>> Modules;
+std::vector<LoopDetails> LoopsVec;
+//MemoryBuffer *MB;
+
+LoopDetails AnalyzeLoops(Function &F, legacy::FunctionPassManager &FPM) {
+  LoopDetails Details;
+  Details.F = &F;
+  
+  DominatorTree DT;
+  LoopInfo LI;
+  DT.recalculate(F);
+  LI.analyze(DT);
+  
+  const Loop *L = *LI.begin();
+  
+  if (!L) {
+    errs() << "Extracted function didn't have a loop\n";
+    exit(1);
+  }
+  
+  // Calculate number of exit blocks
+  SmallVector<BasicBlock*, 16> ExitingBlocks;
+  L->getExitingBlocks(ExitingBlocks);
+  Details.ExitNodes = ExitingBlocks.size();
+  
+  // Find if loop as known bounds
+  TargetLibraryInfoImpl TLII;
+  TargetLibraryInfo TLI(TLII);
+  AssumptionCache AC(F);
+  ScalarEvolution SE(F, TLI, AC, DT, LI);
+  Details.KnownBounds = !isa<SCEVCouldNotCompute>(SE.getBackedgeTakenCount(L));
+  NumDeterminableBounds += Details.KnownBounds;
+  
+  // Get Hotness information
+  BranchProbabilityInfo BPI(F, LI);
+  BlockFrequencyInfo BFI(F, BPI, LI);
+  BasicBlock *Incoming, *Backedge;
+  if (L->getIncomingAndBackEdge(Incoming, Backedge)) {
+    BlockFrequency BlockFreq = BFI.getBlockFreq(Backedge);
+    Details.Hotness = BlockFreq.getFrequency();
+  }
+  
+  // Find it it has been vectorized of not
+  FPM.run(F);
+  Details.VecRes = VectorizeRes;
+  
+  return Details;
+  }
+
+void AnalyzeModules() {
+  auto FPM = createFPM(*ModulePointer);
+  for (Function &F : *ModulePointer) {
+    if (F.empty())
+      continue;
+    
+    LoopDetails Details = AnalyzeLoops(F, FPM);
+    LoopsVec.push_back(Details);
+  }
+}
+
+Error ProcessRemarks(StringRef InputFileName) {
+  std::remove(OutputFileName.c_str());
+  auto Buf = MemoryBuffer::getFile(InputFileName);
+  if (auto EC = Buf.getError()) {
+    errs() << "Buffer error!\n";
+    exit(1);
+  }
+  
+  auto MaybeParser = remarks::createRemarkParserFromMeta(remarks::Format::Bitstream, (*Buf)->getBuffer());
+  if (!MaybeParser)
+    return MaybeParser.takeError();
+  
+  auto &Parser = **MaybeParser;
+  auto MaybeRemark = Parser.next();
+  
+  while (MaybeRemark) {
+    const remarks::Remark &Remark = **MaybeRemark;
+    const auto &PassName = Remark.PassName;
+    
+    if (auto Hotness = Remark.Hotness) {
+//      dbgs() << "Remark: " << Remark.getArgsAsMsg() << "\n";
+      dbgs() << "Hotness: " << Hotness.value() << "\n";
+    }
+    if (PassName.equals("loop-extract-analysis")) {
+      const auto &RemarkName = Remark.RemarkName;
+      if (RemarkName.equals("ModuleDump")) {
+        std::string ModuleString = Remark.getArgsAsMsg();
+
+        auto MB = MemoryBuffer::getMemBuffer(ModuleString);
+        SMDiagnostic Err;
+        ModulePointer = parseIR(MB->getMemBufferRef(), Err, Context);
+        Dumps++;
+      } else if (RemarkName.equals("Extracted")) {
+        Extracted += std::stoi(Remark.getArgsAsMsg());
+      } else if (RemarkName.equals("NotExtracted")) {
+        NotExtracted += std::stoi(Remark.getArgsAsMsg());
+      } else if (RemarkName.equals("NotSimplified")) {
+        NotSimplified += std::stoi(Remark.getArgsAsMsg());
+      } else if (RemarkName.equals("Contained")) {
+        Contained += std::stoi(Remark.getArgsAsMsg());
+      }
+      MaybeRemark = Parser.next();
+    }
+  }
+  
+  auto E = MaybeRemark.takeError();
+  if (!E.isA<remarks::EndOfFileError>())
+    return E;
+
+  consumeError(std::move(E));
+  
+  return Error::success();
+}
+
+std::unique_ptr<Module> getLoopModule(LLVMContext &Context) {
+  SMDiagnostic Err;
+  std::unique_ptr<Module> M = parseIRFile(OutputFileName, Err, Context);
+  if (!M) {
+    errs() << "Unable to parse IR file!\n";
+    Err.print("yes", errs());
+    exit(1);
+  }
+  return M;
+}
+
+void printFunctionNames() {
+  dbgs() << "Functions:\n";
+  for (LoopDetails &Details : LoopsVec) {
+    dbgs() << Details.F->getName() << "\n";
+  }
+  dbgs() << "\n";
+}
+
+void printSummaryStats() {
+  dbgs() << "\n_______________\n";
+  dbgs() << "Summary Stats: \n";
+  dbgs() << "# of module dumps: " << Dumps << "\n\n";
+
+  // dbgs() << "Not extracted because not in Simplified Form: " << NotSimplified << "\n";
+  // dbgs() << "Simplied form but still unable to extract: " << NotExtracted << "\n";
+  dbgs() << "Extracted: " << Extracted << "\n";
+  dbgs() << "Contained in extracted loops: " << Contained << "\n\n";
+  
+  dbgs() << "Total known bounds: " << NumDeterminableBounds << "\n";
+  dbgs() << "Total Vectorized: " << VectorizeCounter.NumSuccess << "\n";
+  dbgs() << "# Cannot vectorize - contains call instruction: " << VectorizeCounter.NumContainsCallInstruction << "\n";
+  dbgs() << "\n";
+}
+
+std::string VectorizeResToString(VectorizationResult Res) {
+  switch (Res) {
+    case VectorizationResult::Success:
+      return "Success!";
+    case VectorizationResult::ContainsCallInstruction:
+      return "Failed - contains call instruction";
+    case VectorizationResult::NotProfitable:
+      return "Failed - not profitable";
+    default:
+      return "Failed - other";
+  }
+}
+
+void printLoopSummary(LoopDetails Details) {
+  dbgs() << "IR Dump: \n";
+  dbgs() << *Details.F << "\n";
+  dbgs() << "Name: " << Details.F->getName() << "\n";
+  dbgs() << "Known Bounds: " << Details.KnownBounds << "\n";
+  dbgs() << "Exit Nodes: " << Details.ExitNodes << "\n";
+  dbgs() << "Vectorization Status: " <<
+    VectorizeResToString(Details.VecRes) << "\n";
+  dbgs() << "Hotness: " << Details.Hotness << "\n";
+  
+}
+
+void beginQuerying() {
+  while (true) {
+    dbgs() << ">> ";
+    std::string Query;
+    std::cin >> Query;
+    if (Query.empty()) {
+      return;
+    }
+    Function *F = ModulePointer->getFunction(Query);
+    if (!F) {
+      dbgs() << "Not a valid function!\n";
+      continue;
+    }
+    
+    for (LoopDetails Loop : LoopsVec) {
+      if (F == Loop.F) {
+        printLoopSummary(Loop);
+        break;
+      }
+    }
+  }
+}
+
+void sortLoopsByHotness() {
+  std::sort(LoopsVec.begin(), LoopsVec.end(), [](LoopDetails Left, LoopDetails Right){
+    return Left.Hotness > Right.Hotness;
+  });
+}
+
+int main(int argc, char **argv) {
+  InitLLVM X(argc, argv);
+
+  cl::ParseCommandLineOptions(argc, argv,
+                              "Extract module from remark and put it into a file\n");
+
+  InitializeAllTargetInfos();
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmParsers();
+  InitializeAllAsmPrinters();
+  InitializeAllDisassemblers();
+  
+  Context.setDiagnosticHandler(std::make_unique<MyDiagnosticHandler>());
+  
+  Error E = ProcessRemarks(InputFileName);
+  
+  if (E) {
+    errs() << "Error parsing Remarks!\n";
+    exit(1);
+  }
+  
+//  if (Modules.empty()) {
+//    errs() << "Could not find any loop remarks!\n";
+//    exit(1);
+//  }
+  
+  AnalyzeModules();
+  
+  sortLoopsByHotness();
+  printFunctionNames();
+  printSummaryStats();
+  
+  handleAllErrors(std::move(E), [&](const ErrorInfoBase &PE) {
+        PE.log(WithColor::error());
+        errs() << '\n';
+      });
+  
+  beginQuerying();
+  
+  return 0;
+}