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
@@ -318,6 +318,11 @@
   unsigned RolledDynamicCost;
 };
 
+enum class UnrollingOption : bool {
+  Full,
+  Partial,
+};
+
 } // end anonymous namespace
 
 /// Figure out if the loop is worth full unrolling.
@@ -753,24 +758,23 @@
   }
 };
 
-bool unrollingLogic(bool FullOrPartial, Loop *L, const TargetTransformInfo &TTI,
-                    DominatorTree &DT, ScalarEvolution &SE,
-                    const SmallPtrSetImpl<const Value *> &EphValues,
-                    OptimizationRemarkEmitter *ORE, bool MaxOrZero,
-                    unsigned LoopSize, unsigned &TripMultiple,
-                    unsigned &TripCount, unsigned &MaxTripCount,
-                    UnrollCostEstimator UCE,
-                    TargetTransformInfo::UnrollingPreferences &UP,
-                    TargetTransformInfo::PeelingPreferences &PP,
-                    bool &UseUpperBound) {
-
-  bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0;
-
-  bool PragmaFullUnroll = hasUnrollFullPragma(L);
-  unsigned PragmaCount = unrollCountPragmaValue(L);
-  bool PragmaEnableUnroll = hasUnrollEnablePragma(L);
-  bool ExplicitUnroll = PragmaCount > 0 || PragmaFullUnroll ||
-                        PragmaEnableUnroll || UserUnrollCount;
+bool shouldUnroll(UnrollingOption UO, Loop *L, const TargetTransformInfo &TTI,
+                  DominatorTree &DT, ScalarEvolution &SE,
+                  const SmallPtrSetImpl<const Value *> &EphValues,
+                  OptimizationRemarkEmitter *ORE, bool MaxOrZero,
+                  unsigned LoopSize, unsigned &TripMultiple, unsigned TripCount,
+                  unsigned MaxTripCount, UnrollCostEstimator UCE,
+                  TargetTransformInfo::UnrollingPreferences &UP,
+                  TargetTransformInfo::PeelingPreferences &PP,
+                  bool &UseUpperBound) {
+
+  const bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0;
+
+  const bool PragmaFullUnroll = hasUnrollFullPragma(L);
+  const unsigned PragmaCount = unrollCountPragmaValue(L);
+  const bool PragmaEnableUnroll = hasUnrollEnablePragma(L);
+  const bool ExplicitUnroll = PragmaCount > 0 || PragmaFullUnroll ||
+                              PragmaEnableUnroll || UserUnrollCount;
 
   if (PragmaFullUnroll)
     ORE->emit([&]() {
@@ -782,7 +786,7 @@
                 "because loop has a runtime trip count.";
     });
 
-  if (FullOrPartial) {
+  if (UO == UnrollingOption::Full) {
 
     // Using unroll pragma
     if (UnrollCount.getNumOccurrences() > 0) {
@@ -859,7 +863,9 @@
         }
       }
     }
-  } else {
+  }
+
+  if (UO == UnrollingOption::Partial) {
     if (TripCount) {
       UP.Partial |= ExplicitUnroll;
       if (!UP.Partial) {
@@ -919,8 +925,10 @@
         });
       LLVM_DEBUG(dbgs() << "  partially unrolling with count: " << UP.Count
                         << "\n");
+
       return ExplicitUnroll;
     }
+    DEBUG_WITH_TYPE("mypass", dbgs() << UP.Count);
   }
   UP.Runtime |= PragmaEnableUnroll || PragmaCount > 0 || UserUnrollCount;
 
@@ -938,47 +946,19 @@
 bool llvm::computeUnrollCount(
     Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI,
     ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues,
-    OptimizationRemarkEmitter *ORE, bool MaxOrZero, unsigned LoopSize, 
-    unsigned &TripMultiple, unsigned &TripCount,  unsigned &MaxTripCount, UnrollCostEstimator UCE, 
-    TargetTransformInfo::UnrollingPreferences &UP, TargetTransformInfo::PeelingPreferences &PP, bool &UseUpperBound)
- {
-
-    bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0;
-
-    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;
-    }
+    OptimizationRemarkEmitter *ORE, unsigned &TripCount, unsigned MaxTripCount,
+    bool MaxOrZero, unsigned &TripMultiple, unsigned LoopSize,
+    TargetTransformInfo::UnrollingPreferences &UP,
+    TargetTransformInfo::PeelingPreferences &PP, bool &UseUpperBound) {
 
-  bool tryFullUnroll = true;
+  UnrollCostEstimator UCE(*L, LoopSize);
 
   bool ExplicitUnroll = false;
 
-  ExplicitUnroll = unrollingLogic(tryFullUnroll, L, TTI, DT, SE, EphValues, ORE,
-                                  MaxOrZero, LoopSize, TripMultiple, TripCount,
-                                  MaxTripCount, UCE, UP, PP, UseUpperBound);
+  ExplicitUnroll =
+      shouldUnroll(UnrollingOption::Full, 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);
@@ -987,11 +967,11 @@
     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);
+  ExplicitUnroll =
+      shouldUnroll(UnrollingOption::Partial, 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.");
@@ -1020,7 +1000,6 @@
   }
 
   // Reduce count based on the type of unrolling and the threshold values.
-  // UP.Runtime |= PragmaEnableUnroll || PragmaCount > 0 || UserUnrollCount;
 
   if (!UP.Runtime) {
     LLVM_DEBUG(