New IR pass: LoopExitValues

[srking]

Summary

This optimization finds loop exit values reevaluated after the loop execution and replaces them by the corresponding exit values if they are available. Such sequences can arise after the SimplifyIndVals+LoopStrengthReduce passes. This pass should be run after LoopStrengthReduce.

[hfinkel]

lib/CodeGen/Passes.cpp

411

Fix indenting.

lib/Transforms/Scalar/LoopExitValues.cpp

1

Stale header comment.

149

not -> ! [to match our general conventions]

154

You should do the type-based validity checking prior to calling DT.dominates (which is going to be significantly more expensive).

Also, when do the types not match? Can getSCEVAtScope return an SCEV with a different type than its argument?

[mzolotukhin]

Hi Steve,

I wonder if it might be related to PR24920 (and D12765). Out of curiosity, could you check what happens in your testcase with the patch from there applied?
Also, some comments inline:

Thanks,
Michael

lib/Transforms/Scalar/LoopExitValues.cpp

32

s/is/in/

135

This resembles what SCEVExpander does (particularly, findExistingExpansion function). Would it be possible/beneficial to just reuse it here somehow?

test/Transforms/LoopExitValues/matrix_mul.ll

1–2

It probably needs ; REQUIRES: Asserts

[danilaml]

Any particular reason this was never followed through? This pass might solve https://bugs.llvm.org/show_bug.cgi?id=42965 .

docs/Passes.rst

 -----------------------------------------
 
 This pass performs a strength reduction on array references inside loops that
 have as one or more of their components the loop induction variable.  This is
 accomplished by creating a new value to hold the initial value of the array
 access for the first iteration, and then creating a new GEP instruction in the
 loop to increment the value by the appropriate amount.
 
+``-loop-exit-values``: Optimize Loop Exit Values
+------------------------------------------------
+
+This optimization finds loop exit values reevaluated after the loop
+execution and replaces them by the corresponding exit values if they are
+available. Such sequencies can arise after SimplifyIndVars and
+LoopStrengthReduce passes. This pass should be run after LoopStrengthReduce.
+
 ``-loop-rotate``: Rotate Loops
 ------------------------------
 
 A simple loop rotation transformation.
 
 ``-loop-simplify``: Canonicalize natural loops
 ----------------------------------------------
 

include/llvm/InitializePasses.h

 void initializeLoopDeletionPass(PassRegistry&);
 void initializeLoopExtractorPass(PassRegistry&);
 void initializeLoopInfoWrapperPassPass(PassRegistry&);
 void initializeLoopInterchangePass(PassRegistry &);
 void initializeLoopInstSimplifyPass(PassRegistry&);
 void initializeLoopRotatePass(PassRegistry&);
 void initializeLoopSimplifyPass(PassRegistry&);
 void initializeLoopStrengthReducePass(PassRegistry&);
+void initializeLoopExitValuesPass(PassRegistry&);
 void initializeGlobalMergePass(PassRegistry&);
 void initializeLoopRerollPass(PassRegistry&);
 void initializeLoopUnrollPass(PassRegistry&);
 void initializeLoopUnswitchPass(PassRegistry&);
 void initializeLoopIdiomRecognizePass(PassRegistry&);
 void initializeLowerAtomicPass(PassRegistry&);
 void initializeLowerBitSetsPass(PassRegistry&);
 void initializeLowerExpectIntrinsicPass(PassRegistry&);

include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createInternalizePass();
       (void) llvm::createLCSSAPass();
       (void) llvm::createLICMPass();
       (void) llvm::createLazyValueInfoPass();
       (void) llvm::createLoopExtractorPass();
       (void) llvm::createLoopInterchangePass();
       (void) llvm::createLoopSimplifyPass();
       (void) llvm::createLoopStrengthReducePass();
+      (void) llvm::createLoopExitValuesPass();
       (void) llvm::createLoopRerollPass();
       (void) llvm::createLoopUnrollPass();
       (void) llvm::createLoopUnswitchPass();
       (void) llvm::createLoopIdiomPass();
       (void) llvm::createLoopRotatePass();
       (void) llvm::createLowerExpectIntrinsicPass();
       (void) llvm::createLowerInvokePass();
       (void) llvm::createLowerSwitchPass();

include/llvm/Transforms/Scalar.h

 //
 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use
 // a loop's canonical induction variable as one of their indices.
 //
 Pass *createLoopStrengthReducePass();
 
 //===----------------------------------------------------------------------===//
 //
+// LoopExitValues - This pass finds loop exit values reevaluated after the
+// loop execution and replaces them by the corresponding values if they are
+// available. Such sequencies often arise after SimplifyIndVars +
+// LoopStrengthReduce. This pass should be run after LoopStrengthReduce.
+//
+Pass *createLoopExitValuesPass();
+
+//===----------------------------------------------------------------------===//
+//
 // GlobalMerge - This pass merges internal (by default) globals into structs
 // to enable reuse of a base pointer by indexed addressing modes.
 // It can also be configured to focus on size optimizations only.
 //
 Pass *createGlobalMergePass(const TargetMachine *TM, unsigned MaximalOffset,
                             bool OnlyOptimizeForSize = false,
                             bool MergeExternalByDefault = false);
 

lib/CodeGen/Passes.cpp

static cl::opt<cl::boolOrDefault> OptimizeRegAlloc(
     cl::desc("Enable optimized register allocation compilation path."));
 static cl::opt<bool> DisablePostRAMachineLICM("disable-postra-machine-licm",
     cl::Hidden,
     cl::desc("Disable Machine LICM"));
 static cl::opt<bool> DisableMachineSink("disable-machine-sink", cl::Hidden,
     cl::desc("Disable Machine Sinking"));
 static cl::opt<bool> DisableLSR("disable-lsr", cl::Hidden,
     cl::desc("Disable Loop Strength Reduction Pass"));
+static cl::opt<bool> DisableLoopExitVals("disable-loop-exit-vals", cl::Hidden,
+    cl::desc("Disable LoopExitValues pass"));
 static cl::opt<bool> DisableConstantHoisting("disable-constant-hoisting",
     cl::Hidden, cl::desc("Disable ConstantHoisting"));
 static cl::opt<bool> DisableCGP("disable-cgp", cl::Hidden,
     cl::desc("Disable Codegen Prepare"));
 static cl::opt<bool> DisableCopyProp("disable-copyprop", cl::Hidden,
     cl::desc("Disable Copy Propagation pass"));
 static cl::opt<bool> DisablePartialLibcallInlining("disable-partial-libcall-inlining",
     cl::Hidden, cl::desc("Disable Partial Libcall Inlining"));
 static cl::opt<bool> EnableImplicitNullChecks(
     "enable-implicit-null-checks",
     cl::desc("Fold null checks into faulting memory operations"),
     cl::init(false));
 static cl::opt<bool> PrintLSR("print-lsr-output", cl::Hidden,
     cl::desc("Print LLVM IR produced by the loop-reduce pass"));
+static cl::opt<bool> PrintLoopExitValues("print-loop-exit-values-output", cl::Hidden,
+    cl::desc("Print LLVM IR produced by the loop exit value optimization pass"));
 static cl::opt<bool> PrintISelInput("print-isel-input", cl::Hidden,
     cl::desc("Print LLVM IR input to isel pass"));
 static cl::opt<bool> PrintGCInfo("print-gc", cl::Hidden,
     cl::desc("Dump garbage collector data"));
 static cl::opt<bool> VerifyMachineCode("verify-machineinstrs", cl::Hidden,
     cl::desc("Verify generated machine code"),
     cl::init(false),
     cl::ZeroOrMore);
void TargetPassConfig::addIRPasses() {
 
   // Run loop strength reduction before anything else.
   if (getOptLevel() != CodeGenOpt::None && !DisableLSR) {
     addPass(createLoopStrengthReducePass());
     if (PrintLSR)
       addPass(createPrintFunctionPass(dbgs(), "\n\n*** Code after LSR ***\n"));
   }
 
+  if (getOptLevel() != CodeGenOpt::None && !DisableLoopExitVals) {
+    addPass(createLoopExitValuesPass());
+  if (PrintLoopExitValues)
+    addPass(createPrintFunctionPass(dbgs(), "\n\n*** Code after Loop Exit Values Optimization **\n"));
+  }
+
   // Run GC lowering passes for builtin collectors
   // TODO: add a pass insertion point here
   addPass(createGCLoweringPass());
   addPass(createShadowStackGCLoweringPass());
 
   // Make sure that no unreachable blocks are instruction selected.
   addPass(createUnreachableBlockEliminationPass());
 

lib/Transforms/Scalar/CMakeLists.txt

add_llvm_library(LLVMScalarOpts
   LoopStrengthReduce.cpp
   LoopUnrollPass.cpp
   LoopUnswitch.cpp
   LowerAtomic.cpp
   LowerExpectIntrinsic.cpp
   MemCpyOptimizer.cpp
   MergedLoadStoreMotion.cpp
   NaryReassociate.cpp
+  LoopExitValues.cpp
   PartiallyInlineLibCalls.cpp
   PlaceSafepoints.cpp
   Reassociate.cpp
   Reg2Mem.cpp
   RewriteStatepointsForGC.cpp
   SCCP.cpp
   SROA.cpp
   Scalar.cpp

lib/Transforms/Scalar/LoopExitValues.cpp

+//===- LoopStrengthReduce.cpp - Strength Reduce IVs in Loops --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This optimization finds loop exit values reevaluated after the loop
+// execution and replaces them by the corresponding exit values if they are
+// available. Such sequences can arise after SimplifyIndVars +
+// LoopStrengthReduce passes. This pass should be run after LoopStrengthReduce.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Analysis/IVUsers.h"
+#include "llvm/Analysis/LoopPass.h"
+#include "llvm/Analysis/ScalarEvolutionExpander.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Transforms/Utils/Local.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "loop-exit-values"
+
+/// If any of the instructions is the specified set are trivially dead, delete
+/// them and see if this makes any of their operands subsequently dead.
+/// TODO: This function is identical to one in LoopStrengthReduce.  Move these
+/// TODO: to one common location.
+static bool
+DeleteTriviallyDeadInstructions(SmallVectorImpl<WeakVH> &DeadInsts) {
+  bool Changed = false;
+
+  while (!DeadInsts.empty()) {
+    Value *V = DeadInsts.pop_back_val();
+    Instruction *I = dyn_cast_or_null<Instruction>(V);
+
+    if (!I || !isInstructionTriviallyDead(I))
+      continue;
+
+    for (Use &O : I->operands())
+      if (Instruction *U = dyn_cast<Instruction>(O)) {
+        O = nullptr;
+        if (U->use_empty())
+          DeadInsts.emplace_back(U);
+      }
+
+    I->eraseFromParent();
+    Changed = true;
+  }
+
+  return Changed;
+}
+
+static void collectNestedLoops(Loop *L, std::vector<Loop *> &Loops) {
+  Loops.push_back(L);
+  for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
+    collectNestedLoops(*I, Loops);
+}
+
+static void collectLoops(LoopInfo &LI, std::vector<Loop *> &Loops) {
+  for (LoopInfo::iterator I = LI.begin(), E = LI.end(); I != E; ++I)
+    collectNestedLoops(*I, Loops);
+}
+
+namespace {
+
+class LoopExitValues : public FunctionPass {
+public:
+  static char ID; // Pass ID, replacement for typeid
+  LoopExitValues();
+
+private:
+  bool runOnFunction(Function &F) override;
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+};
+
+} // anonymous
+
+char LoopExitValues::ID = 0;
+INITIALIZE_PASS_BEGIN(LoopExitValues, "loop-exit-values",
+                      "Optimize loop exit values", false, false)
+INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
+INITIALIZE_PASS_END(LoopExitValues, "loop-exit-values",
+                    "Optimize loop exit values", false, false)
+
+Pass *llvm::createLoopExitValuesPass() {
+  return new LoopExitValues();
+}
+
+LoopExitValues::LoopExitValues()
+        : FunctionPass(ID) {
+  initializeLoopExitValuesPass(*PassRegistry::getPassRegistry());
+}
+
+bool LoopExitValues::runOnFunction(Function &F) {
+  ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
+  DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  LoopInfo &LI =  getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
+
+  std::vector<Loop *> Loops;
+  collectLoops(LI, Loops);
+
+  // Collect exit values available after each of the loops
+  typedef DenseMap<const SCEV *, std::vector<Instruction *> >SCEVToInstMap;
+  SCEVToInstMap SCEVToInstr;
+  for (Loop* L : Loops) {
+    for (BasicBlock* BB : L->getBlocks()) {
+      for (BasicBlock::iterator I : *BB) {
+        if (!SE.isSCEVable(I->getType()))
+          continue;
+
+        const SCEV *ExitValue = SE.getSCEVAtScope(SE.getSCEV(&*I),
+                                                  L->getParentLoop());
+        if (!SE.isLoopInvariant(ExitValue, L) ||
+            ExitValue->getSCEVType() == scUnknown ||
+            ExitValue->getSCEVType() == scCouldNotCompute)
+          continue;
+
+        SCEVToInstr[ExitValue].push_back(&*I);
+      }
+    }
+  }
+  if (SCEVToInstr.empty())
+    return false;
+
+  // Find similar values
+  bool Changed = false;
+  SmallVector<WeakVH, 16> DeadInsts;
+  for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
+    if (!SE.isSCEVable(I->getType()))
+      continue;
+
+    // Since SCEVs are unique, we may use simple pointer comparison here.
+    const SCEV *SV = SE.getSCEV(&*I);
+    SCEVToInstMap::const_iterator iter = SCEVToInstr.find(SV);
+    if (iter == SCEVToInstr.end())
+      continue;
+
+    for (Instruction *Cand : iter->second) {
+      if (not DT.properlyDominates(Cand->getParent(), I->getParent()))
+        continue;
+
+      // Try to replace I with the other instruction.
+      Instruction *NewInstr = Cand;
+      if (NewInstr->getType() != I->getType()) {
+        // If either instruction is a bitcast, that's ok, just insert a
+        // bitcast.  Otherwise, some strange stuff detected, so do not
+        // optimize.
+        if (isa<BitCastInst>(NewInstr) || isa<BitCastInst>(&*I))
+          NewInstr =
+                  new BitCastInst(NewInstr, I->getType(), I->getName(), &*I);
+        else
+          NewInstr = nullptr;
+      }
+
+      if (NewInstr == nullptr)
+        continue;
+
+      DEBUG(dbgs() << "LoopExitValues: Replacing instruction: ");
+      DEBUG(I->dump());
+      DEBUG(dbgs() << "                    with SCEV equivalent: ");
+      DEBUG(Cand->dump());
+      Changed = true;
+      I->replaceAllUsesWith(NewInstr);
+      DeadInsts.push_back(&*I);
+      break;
+    }
+  }
+
+  DeleteTriviallyDeadInstructions(DeadInsts);
+  return Changed;
+}
+
+void LoopExitValues::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequired<DominatorTreeWrapperPass>();
+  AU.addPreserved<DominatorTreeWrapperPass>();
+  AU.addRequired<ScalarEvolutionWrapperPass>();
+  AU.addPreserved<ScalarEvolutionWrapperPass>();
+  AU.addRequired<LoopInfoWrapperPass>();
+  AU.addPreserved<LoopInfoWrapperPass>();
+}
+

lib/Transforms/Scalar/Scalar.cpp

void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeJumpThreadingPass(Registry);
   initializeLICMPass(Registry);
   initializeLoopDeletionPass(Registry);
   initializeLoopAccessAnalysisPass(Registry);
   initializeLoopInstSimplifyPass(Registry);
   initializeLoopInterchangePass(Registry);
   initializeLoopRotatePass(Registry);
   initializeLoopStrengthReducePass(Registry);
+  initializeLoopExitValuesPass(Registry);
   initializeLoopRerollPass(Registry);
   initializeLoopUnrollPass(Registry);
   initializeLoopUnswitchPass(Registry);
   initializeLoopIdiomRecognizePass(Registry);
   initializeLowerAtomicPass(Registry);
   initializeLowerExpectIntrinsicPass(Registry);
   initializeMemCpyOptPass(Registry);
   initializeMergedLoadStoreMotionPass(Registry);

test/CodeGen/Generic/stop-after.ll

 ; RUN: llc < %s -debug-pass=Structure -stop-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=STOP
 ; RUN: llc < %s -debug-pass=Structure -start-after=loop-reduce -o /dev/null 2>&1 | FileCheck %s -check-prefix=START
 
 ; STOP: -loop-reduce
 ; STOP: Loop Strength Reduction
 ; STOP-NEXT: Machine Function Analysis
 ; STOP-NEXT: MIR Printing Pass
 
-; START: -machine-branch-prob -gc-lowering
+; START: -machine-branch-prob -domtree -loops -scalar-evolution -loop-exit-values
 ; START: FunctionPass Manager
-; START-NEXT: Lower Garbage Collection Instructions
+; START-NEXT: Dominator Tree Construction
+; START-NEXT: Natural Loop Information
+; START-NEXT: Scalar Evolution Analysis
+; START-NEXT: Optimize loop exit values
+

test/CodeGen/X86/lsr-loop-exit-cond.ll

 ; RUN: llc -mtriple=x86_64-darwin -mcpu=generic < %s | FileCheck %s
 ; RUN: llc -mtriple=x86_64-darwin -mcpu=atom < %s | FileCheck -check-prefix=ATOM %s
 
 ; CHECK-LABEL: t:
-; CHECK: movl (%r9,%rax,4), %e{{..}}
+; CHECK: movl (%r9,%{{.+}},4), %e{{..}}
 ; CHECK-NEXT: decq
 ; CHECK-NEXT: jne
 
 ; ATOM-LABEL: t:
 ; ATOM: movl (%r9,%r{{.+}},4), %e{{..}}
 ; ATOM-NEXT: decq
 ; ATOM-NEXT: jne
 

test/CodeGen/X86/pr11202.ll

l1:                                               ; preds = %l2, %entry
   %a = zext i1 false to i32
   br label %l2
 
 l2:                                               ; preds = %l1
   %b = zext i1 false to i32
   br label %l1
 }
 
-; CHECK: .Ltmp0:                                 # Address of block that was removed by CodeGen
+; CHECK: .Ltmp0:
 ; CHECK: .quad  .Ltmp0

test/Transforms/LoopExitValues/matrix_mul.ll

+; RUN: llc %s -print-lsr-output -print-loop-exit-values-output -o /dev/null 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
+target triple = "i686-unknown-unknown"
+
+define void @matrix_mul(i32 %Size, i32* nocapture %Dst, i32* nocapture readonly %Src, i32 %Val) {
+entry:
+  %cmp.25 = icmp eq i32 %Size, 0
+  br i1 %cmp.25, label %for.cond.cleanup, label %for.body.4.lr.ph
+
+for.body.4.lr.ph:                                 ; preds = %entry, %for.cond.cleanup.3
+  %Outer.026 = phi i32 [ %inc10, %for.cond.cleanup.3 ], [ 0, %entry ]
+  %mul = mul i32 %Outer.026, %Size
+  br label %for.body.4
+
+for.cond.cleanup:                                 ; preds = %for.cond.cleanup.3, %entry
+  ret void
+
+for.cond.cleanup.3:                               ; preds = %for.body.4
+  %inc10 = add nuw nsw i32 %Outer.026, 1
+  %exitcond27 = icmp eq i32 %inc10, %Size
+  br i1 %exitcond27, label %for.cond.cleanup, label %for.body.4.lr.ph
+
+for.body.4:                                       ; preds = %for.body.4, %for.body.4.lr.ph
+  %Inner.024 = phi i32 [ 0, %for.body.4.lr.ph ], [ %inc, %for.body.4 ]
+  %add = add i32 %Inner.024, %mul
+  %arrayidx = getelementptr inbounds i32, i32* %Src, i32 %add
+  %0 = load i32, i32* %arrayidx, align 4, !tbaa !1
+  %mul5 = mul i32 %0, %Val
+  %arrayidx8 = getelementptr inbounds i32, i32* %Dst, i32 %add
+  store i32 %mul5, i32* %arrayidx8, align 4, !tbaa !1
+  %inc = add nuw nsw i32 %Inner.024, 1
+  %exitcond = icmp eq i32 %inc, %Size
+  br i1 %exitcond, label %for.cond.cleanup.3, label %for.body.4
+}
+
+!1 = !{!2, !2, i64 0}
+!2 = !{!"int", !3, i64 0}
+!3 = !{!"omnipotent char", !4, i64 0}
+!4 = !{!"Simple C/C++ TBAA"}
+
+
+; Verify LSR produced the expected bitcasts
+; CHECK: Code after LSR
+; CHECK: [ %2, {{.+}} ]
+; CHECK-NEXT: [ %1, {{.+}} ]
+
+; Verify Loop Exit Values pass replaced these with available GEPs
+; CHECK: Code after Loop Exit Values
+; CHECK: [ %scevgep9, {{.+}} ]
+; CHECK-NEXT: [ %scevgep4, {{.+}} ]

test/Transforms/LoopStrengthReduce/ARM/ivchain-ARM.ll

 ; post-increment addressing. However, the loads should use
 ; post-increment addressing, no add's or add.w's beyond the three
 ; mentioned. Most importantly, there should be no spills or reloads!
 ;
 ; A9: testNeon:
 ; A9: %.lr.ph
 ; A9-NOT: lsl.w
 ; A9-NOT: {{ldr|str|adds|add r}}
-; A9: vst1.8 {{.*}} [r{{[0-9]+}}]!
+; A9: vst1.8 {{.*}} [{{lr}}]!
 ; A9-NOT: {{ldr|str|adds|add r}}
-; A9: add.w r
+; A9: add.w lr
 ; A9-NOT: {{ldr|str|adds|add r}}
-; A9: add.w r
+; A9: add.w lr
 ; A9-NOT: {{ldr|str|adds|add r}}
 ; A9-NOT: add.w r
+; A9-NOT: add.w lr
 ; A9: bne
 define hidden void @testNeon(i8* %ref_data, i32 %ref_stride, i32 %limit, <16 x i8>* nocapture %data) nounwind optsize {
   %1 = icmp sgt i32 %limit, 0
   br i1 %1, label %.lr.ph, label %45
 
 .lr.ph:                                           ; preds = %0
   %2 = shl nsw i32 %ref_stride, 1
   %3 = mul nsw i32 %ref_stride, 3

tools/llc/llc.cpp

int main(int argc, char **argv) {
   InitializeAllAsmParsers();
 
   // Initialize codegen and IR passes used by llc so that the -print-after,
   // -print-before, and -stop-after options work.
   PassRegistry *Registry = PassRegistry::getPassRegistry();
   initializeCore(*Registry);
   initializeCodeGen(*Registry);
   initializeLoopStrengthReducePass(*Registry);
+  initializeLoopExitValuesPass(*Registry);
   initializeLowerIntrinsicsPass(*Registry);
   initializeUnreachableBlockElimPass(*Registry);
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");