diff --git a/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp b/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp
--- a/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp
+++ b/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp
@@ -753,146 +753,116 @@
   }
 };
 
-// Returns true if unroll count was set explicitly.
-// Calculates unroll count and writes it to UP.Count.
-// Unless IgnoreUser is true, will also use metadata and command-line options
-// that are specific to to the LoopUnroll pass (which, for instance, are
-// irrelevant for the LoopUnrollAndJam pass).
-// FIXME: This function is used by LoopUnroll and LoopUnrollAndJam, but consumes
-// many LoopUnroll-specific options. The shared functionality should be
-// refactored into it own function.
-bool llvm::computeUnrollCount(
-    Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI,
+
+
+bool unrollingLogic(bool FullOrPartial,Loop *L,
+    const TargetTransformInfo &TTI, DominatorTree &DT,
     ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues,
-    OptimizationRemarkEmitter *ORE, unsigned &TripCount, unsigned MaxTripCount,
-    bool MaxOrZero, unsigned &TripMultiple, unsigned LoopSize,
-    TargetTransformInfo::UnrollingPreferences &UP,
-    TargetTransformInfo::PeelingPreferences &PP, bool &UseUpperBound) {
+    OptimizationRemarkEmitter *ORE, bool MaxOrZero, unsigned LoopSize, 
+    unsigned &TripMultiple, unsigned &TripCount,  unsigned &MaxTripCount, UnrollCostEstimator UCE, 
+    TargetTransformInfo::UnrollingPreferences &UP, TargetTransformInfo::PeelingPreferences &PP, bool &UseUpperBound)
+ {
 
-  UnrollCostEstimator UCE(*L, LoopSize);
+    bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0;
 
-  // Use an explicit peel count that has been specified for testing. In this
-  // case it's not permitted to also specify an explicit unroll count.
-  if (PP.PeelCount) {
-    if (UnrollCount.getNumOccurrences() > 0) {
-      report_fatal_error("Cannot specify both explicit peel count and "
-                         "explicit unroll count");
+    bool PragmaFullUnroll = hasUnrollFullPragma(L);
+    unsigned PragmaCount = unrollCountPragmaValue(L);
+    bool PragmaEnableUnroll = hasUnrollEnablePragma(L);
+    bool ExplicitUnroll = PragmaCount > 0 || PragmaFullUnroll ||
+                          PragmaEnableUnroll || UserUnrollCount;
+
+    if (PragmaFullUnroll)
+    ORE->emit([&]() {
+      return OptimizationRemarkMissed(
+                 DEBUG_TYPE, "CantFullUnrollAsDirectedRuntimeTripCount",
+                 L->getStartLoc(), L->getHeader())
+             << "Unable to fully unroll loop as directed by unroll(full) "
+                "pragma "
+                "because loop has a runtime trip count.";
+    });
+
+  if (FullOrPartial){
+
+   // Using unroll pragma
+    if (UnrollCount.getNumOccurrences() > 0){
+      UP.Count = UnrollCount;
+      UP.AllowExpensiveTripCount = true;
+      UP.Force = true;
+      if (UP.AllowRemainder && UCE.getUnrolledLoopSize(UP) < UP.Threshold)
+        return true;
     }
-    UP.Count = 1;
-    UP.Runtime = false;
-    return true;
-  }
 
-  // Check for explicit Count.
-  // 1st priority is unroll count set by "unroll-count" option.
-  bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0;
-  if (UserUnrollCount) {
-    UP.Count = UnrollCount;
-    UP.AllowExpensiveTripCount = true;
-    UP.Force = true;
-    if (UP.AllowRemainder && UCE.getUnrolledLoopSize(UP) < UP.Threshold)
-      return true;
-  }
+    if (PragmaCount > 0) {
+      UP.Count = PragmaCount;
+      UP.Runtime = true;
+      UP.AllowExpensiveTripCount = true;
+      UP.Force = true;
+      if ((UP.AllowRemainder || (TripMultiple % PragmaCount == 0)) &&
+          UCE.getUnrolledLoopSize(UP) < PragmaUnrollThreshold)
+        return true;
+    }
 
-  // 2nd priority is unroll count set by pragma.
-  unsigned PragmaCount = unrollCountPragmaValue(L);
-  if (PragmaCount > 0) {
-    UP.Count = PragmaCount;
-    UP.Runtime = true;
-    UP.AllowExpensiveTripCount = true;
-    UP.Force = true;
-    if ((UP.AllowRemainder || (TripMultiple % PragmaCount == 0)) &&
-        UCE.getUnrolledLoopSize(UP) < PragmaUnrollThreshold)
-      return true;
-  }
-  bool PragmaFullUnroll = hasUnrollFullPragma(L);
-  if (PragmaFullUnroll && TripCount != 0) {
-    UP.Count = TripCount;
-    if (UCE.getUnrolledLoopSize(UP) < PragmaUnrollThreshold)
-      return false;
-  }
+    if (PragmaFullUnroll && TripCount != 0) {
+      UP.Count = TripCount;
+      if (UCE.getUnrolledLoopSize(UP) < PragmaUnrollThreshold)
+        return false;
+    }
 
-  bool PragmaEnableUnroll = hasUnrollEnablePragma(L);
-  bool ExplicitUnroll = PragmaCount > 0 || PragmaFullUnroll ||
-                        PragmaEnableUnroll || UserUnrollCount;
-
-  if (ExplicitUnroll && TripCount != 0) {
-    // If the loop has an unrolling pragma, we want to be more aggressive with
-    // unrolling limits. Set thresholds to at least the PragmaUnrollThreshold
-    // value which is larger than the default limits.
-    UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold);
-    UP.PartialThreshold =
-        std::max<unsigned>(UP.PartialThreshold, PragmaUnrollThreshold);
-  }
 
-  // 3rd priority is full unroll count.
-  // Full unroll makes sense only when TripCount or its upper bound could be
-  // statically calculated.
-  // Also we need to check if we exceed FullUnrollMaxCount.
-  // If using the upper bound to unroll, TripMultiple should be set to 1 because
-  // we do not know when loop may exit.
-
-  // We can unroll by the upper bound amount if it's generally allowed or if
-  // we know that the loop is executed either the upper bound or zero times.
-  // (MaxOrZero unrolling keeps only the first loop test, so the number of
-  // loop tests remains the same compared to the non-unrolled version, whereas
-  // the generic upper bound unrolling keeps all but the last loop test so the
-  // number of loop tests goes up which may end up being worse on targets with
-  // constrained branch predictor resources so is controlled by an option.)
-  // In addition we only unroll small upper bounds.
-  unsigned FullUnrollMaxTripCount = MaxTripCount;
-  if (!(UP.UpperBound || MaxOrZero) ||
-      FullUnrollMaxTripCount > UnrollMaxUpperBound)
-    FullUnrollMaxTripCount = 0;
-
-  // UnrollByMaxCount and ExactTripCount cannot both be non zero since we only
-  // compute the former when the latter is zero.
-  unsigned ExactTripCount = TripCount;
-  assert((ExactTripCount == 0 || FullUnrollMaxTripCount == 0) &&
-         "ExtractTripCount and UnrollByMaxCount cannot both be non zero.");
-
-  unsigned FullUnrollTripCount =
-      ExactTripCount ? ExactTripCount : FullUnrollMaxTripCount;
-  UP.Count = FullUnrollTripCount;
-  if (FullUnrollTripCount && FullUnrollTripCount <= UP.FullUnrollMaxCount) {
-    // When computing the unrolled size, note that BEInsns are not replicated
-    // like the rest of the loop body.
-    if (UCE.getUnrolledLoopSize(UP) < UP.Threshold) {
-      UseUpperBound = (FullUnrollMaxTripCount == FullUnrollTripCount);
-      TripCount = FullUnrollTripCount;
-      TripMultiple = UP.UpperBound ? 1 : TripMultiple;
-      return ExplicitUnroll;
-    } else {
-      // The loop isn't that small, but we still can fully unroll it if that
-      // helps to remove a significant number of instructions.
-      // To check that, run additional analysis on the loop.
-      if (Optional<EstimatedUnrollCost> Cost = analyzeLoopUnrollCost(
-              L, FullUnrollTripCount, DT, SE, EphValues, TTI,
-              UP.Threshold * UP.MaxPercentThresholdBoost / 100,
-              UP.MaxIterationsCountToAnalyze)) {
-        unsigned Boost =
-            getFullUnrollBoostingFactor(*Cost, UP.MaxPercentThresholdBoost);
-        if (Cost->UnrolledCost < UP.Threshold * Boost / 100) {
-          UseUpperBound = (FullUnrollMaxTripCount == FullUnrollTripCount);
-          TripCount = FullUnrollTripCount;
-          TripMultiple = UP.UpperBound ? 1 : TripMultiple;
-          return ExplicitUnroll;
+    
+    if (ExplicitUnroll && TripCount != 0) {
+      // If the loop has an unrolling pragma, we want to be more aggressive with
+      // unrolling limits. Set thresholds to at least the PragmaUnrollThreshold
+      // value which is larger than the default limits.
+      UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold);
+      UP.PartialThreshold =
+          std::max<unsigned>(UP.PartialThreshold, PragmaUnrollThreshold);
+    }
+
+    unsigned FullUnrollMaxTripCount = MaxTripCount;
+    if (!(UP.UpperBound || MaxOrZero) ||
+        FullUnrollMaxTripCount > UnrollMaxUpperBound)
+      FullUnrollMaxTripCount = 0;
+
+    // UnrollByMaxCount and ExactTripCount cannot both be non zero since we only
+    // compute the former when the latter is zero.
+    unsigned ExactTripCount = TripCount;
+    assert((ExactTripCount == 0 || FullUnrollMaxTripCount == 0) &&
+          "ExtractTripCount and UnrollByMaxCount cannot both be non zero.");
+
+    unsigned FullUnrollTripCount =
+        ExactTripCount ? ExactTripCount : FullUnrollMaxTripCount;
+    UP.Count = FullUnrollTripCount;
+    if (FullUnrollTripCount && FullUnrollTripCount <= UP.FullUnrollMaxCount) {
+      // When computing the unrolled size, note that BEInsns are not replicated
+      // like the rest of the loop body.
+      if (UCE.getUnrolledLoopSize(UP) < UP.Threshold) {
+        UseUpperBound = (FullUnrollMaxTripCount == FullUnrollTripCount);
+        TripCount = FullUnrollTripCount;
+        TripMultiple = UP.UpperBound ? 1 : TripMultiple;
+        return ExplicitUnroll;
+      } else {
+        // The loop isn't that small, but we still can fully unroll it if that
+        // helps to remove a significant number of instructions.
+        // To check that, run additional analysis on the loop.
+        if (Optional<EstimatedUnrollCost> Cost = analyzeLoopUnrollCost(
+                L, FullUnrollTripCount, DT, SE, EphValues, TTI,
+                UP.Threshold * UP.MaxPercentThresholdBoost / 100,
+                UP.MaxIterationsCountToAnalyze)) {
+          unsigned Boost =
+              getFullUnrollBoostingFactor(*Cost, UP.MaxPercentThresholdBoost);
+          if (Cost->UnrolledCost < UP.Threshold * Boost / 100) {
+            UseUpperBound = (FullUnrollMaxTripCount == FullUnrollTripCount);
+            TripCount = FullUnrollTripCount;
+            TripMultiple = UP.UpperBound ? 1 : TripMultiple;
+            return ExplicitUnroll;
+          }
         }
       }
     }
   }
-
-  // 4th priority is loop peeling.
-  computePeelCount(L, LoopSize, PP, TripCount, SE, UP.Threshold);
-  if (PP.PeelCount) {
-    UP.Runtime = false;
-    UP.Count = 1;
-    return ExplicitUnroll;
-  }
-
-  // 5th priority is partial unrolling.
-  // Try partial unroll only when TripCount could be statically calculated.
-  if (TripCount) {
+  else{
+    if (TripCount) {
     UP.Partial |= ExplicitUnroll;
     if (!UP.Partial) {
       LLVM_DEBUG(dbgs() << "  will not try to unroll partially because "
@@ -952,18 +922,71 @@
     LLVM_DEBUG(dbgs() << "  partially unrolling with count: " << UP.Count
                       << "\n");
     return ExplicitUnroll;
+
+    }
+  }
+    UP.Runtime |= PragmaEnableUnroll || PragmaCount > 0 || UserUnrollCount;
+
+    return ExplicitUnroll;
+  
+ }
+// Returns true if unroll count was set explicitly.
+// Calculates unroll count and writes it to UP.Count.
+// Unless IgnoreUser is true, will also use metadata and command-line options
+// that are specific to to the LoopUnroll pass (which, for instance, are
+// irrelevant for the LoopUnrollAndJam pass).
+// FIXME: This function is used by LoopUnroll and LoopUnrollAndJam, but consumes
+// many LoopUnroll-specific options. The shared functionality should be
+// refactored into it own function.
+
+bool llvm::computeUnrollCount(
+    Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI,
+    ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues,
+    OptimizationRemarkEmitter *ORE, unsigned &TripCount, unsigned MaxTripCount,
+    bool MaxOrZero, unsigned &TripMultiple, unsigned LoopSize,
+    TargetTransformInfo::UnrollingPreferences &UP,
+    TargetTransformInfo::PeelingPreferences &PP, bool &UseUpperBound) {
+
+
+
+  UnrollCostEstimator UCE(*L, LoopSize);
+
+  // Use an explicit peel count that has been specified for testing. In this
+  // case it's not permitted to also specify an explicit unroll count.
+  if (PP.PeelCount) {
+    if (UnrollCount.getNumOccurrences() > 0) {
+      report_fatal_error("Cannot specify both explicit peel count and "
+                         "explicit unroll count");
+    }
+    UP.Count = 1;
+    UP.Runtime = false;
+    return true;
   }
+
+  bool tryFullUnroll = true;
+
+  bool ExplicitUnroll = false;
+  
+
+  ExplicitUnroll = unrollingLogic(tryFullUnroll, L, TTI, DT, SE, EphValues, ORE, MaxOrZero, LoopSize,  TripMultiple, TripCount, MaxTripCount, UCE, UP, PP, UseUpperBound);
+
+
+  // 4th priority is loop peeling.
+  computePeelCount(L, LoopSize, PP, TripCount, SE, UP.Threshold);
+  if (PP.PeelCount) {
+    UP.Runtime = false;
+    UP.Count = 1;
+    return ExplicitUnroll;
+  }
+  tryFullUnroll = false;
+
+  ExplicitUnroll = unrollingLogic(tryFullUnroll, L, TTI, DT, SE, EphValues, ORE, MaxOrZero, LoopSize,  TripMultiple, TripCount, MaxTripCount, UCE, UP, PP, UseUpperBound);
+
+
+
   assert(TripCount == 0 &&
          "All cases when TripCount is constant should be covered here.");
-  if (PragmaFullUnroll)
-    ORE->emit([&]() {
-      return OptimizationRemarkMissed(
-                 DEBUG_TYPE, "CantFullUnrollAsDirectedRuntimeTripCount",
-                 L->getStartLoc(), L->getHeader())
-             << "Unable to fully unroll loop as directed by unroll(full) "
-                "pragma "
-                "because loop has a runtime trip count.";
-    });
+
 
   // 6th priority is runtime unrolling.
   // Don't unroll a runtime trip count loop when it is disabled.
@@ -989,7 +1012,8 @@
   }
 
   // Reduce count based on the type of unrolling and the threshold values.
-  UP.Runtime |= PragmaEnableUnroll || PragmaCount > 0 || UserUnrollCount;
+  // UP.Runtime |= PragmaEnableUnroll || PragmaCount > 0 || UserUnrollCount;
+
   if (!UP.Runtime) {
     LLVM_DEBUG(
         dbgs() << "  will not try to unroll loop with runtime trip count "
@@ -1023,7 +1047,7 @@
 
     using namespace ore;
 
-    if (PragmaCount > 0 && !UP.AllowRemainder)
+    if (unrollCountPragmaValue(L) > 0 && !UP.AllowRemainder)
       ORE->emit([&]() {
         return OptimizationRemarkMissed(DEBUG_TYPE,
                                         "DifferentUnrollCountFromDirected",