diff --git a/compiler/optimizing/induction_var_analysis.cc b/compiler/optimizing/induction_var_analysis.cc
index 1ff6bbe..9fb4304 100644
--- a/compiler/optimizing/induction_var_analysis.cc
+++ b/compiler/optimizing/induction_var_analysis.cc
@@ -557,8 +557,8 @@
     InductionInfo* lo_val = a->op_b;
     InductionInfo* hi_val = b;
     // Analyze stride (may be compound).
-    InductionVarRange::Value v1 = InductionVarRange::GetMin(stride, nullptr);
-    InductionVarRange::Value v2 = InductionVarRange::GetMax(stride, nullptr);
+    InductionVarRange::Value v1 = InductionVarRange::GetVal(stride, nullptr, /* is_min */ true);
+    InductionVarRange::Value v2 = InductionVarRange::GetVal(stride, nullptr, /* is_min */ false);
     if (v1.a_constant != 0 || v2.a_constant != 0 || v1.b_constant != v2.b_constant) {
       return;
     }
diff --git a/compiler/optimizing/induction_var_range.cc b/compiler/optimizing/induction_var_range.cc
index 3110427..119a80b 100644
--- a/compiler/optimizing/induction_var_range.cc
+++ b/compiler/optimizing/induction_var_range.cc
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include <limits.h>
-
 #include "induction_var_range.h"
 
+#include <limits>
+
 namespace art {
 
 /** Returns true if 64-bit constant fits in 32-bit constant. */
 static bool CanLongValueFitIntoInt(int64_t c) {
-  return INT_MIN <= c && c <= INT_MAX;
+  return std::numeric_limits<int32_t>::min() <= c && c <= std::numeric_limits<int32_t>::max();
 }
 
 /** Returns true if 32-bit addition can be done safely. */
@@ -88,7 +88,8 @@
                                                             HInstruction* instruction) {
   HLoopInformation* loop = context->GetBlock()->GetLoopInformation();
   if (loop != nullptr) {
-    return GetMin(induction_analysis_->LookupInfo(loop, instruction), GetTripCount(loop, context));
+    return GetVal(induction_analysis_->LookupInfo(loop, instruction),
+                  GetTripCount(loop, context), /* is_min */ true);
   }
   return Value();
 }
@@ -98,7 +99,8 @@
   HLoopInformation* loop = context->GetBlock()->GetLoopInformation();
   if (loop != nullptr) {
     return SimplifyMax(
-        GetMax(induction_analysis_->LookupInfo(loop, instruction), GetTripCount(loop, context)));
+        GetVal(induction_analysis_->LookupInfo(loop, instruction),
+               GetTripCount(loop, context), /* is_min */ false));
   }
   return Value();
 }
@@ -150,73 +152,44 @@
   return Value(instruction, 1, 0);
 }
 
-InductionVarRange::Value InductionVarRange::GetMin(HInductionVarAnalysis::InductionInfo* info,
-                                                   HInductionVarAnalysis::InductionInfo* trip) {
+InductionVarRange::Value InductionVarRange::GetVal(HInductionVarAnalysis::InductionInfo* info,
+                                                   HInductionVarAnalysis::InductionInfo* trip,
+                                                   bool is_min) {
   if (info != nullptr) {
     switch (info->induction_class) {
       case HInductionVarAnalysis::kInvariant:
         // Invariants.
         switch (info->operation) {
-          case HInductionVarAnalysis::kNop:  // normalized: 0
+          case HInductionVarAnalysis::kNop:  // normalized: 0 or TC-1
             DCHECK_EQ(info->op_a, info->op_b);
-            return Value(0);
+            return is_min ? Value(0)
+                          : SubValue(GetVal(info->op_b, trip, is_min), Value(1));
           case HInductionVarAnalysis::kAdd:
-            return AddValue(GetMin(info->op_a, trip), GetMin(info->op_b, trip));
-          case HInductionVarAnalysis::kSub:  // second max!
-            return SubValue(GetMin(info->op_a, trip), GetMax(info->op_b, trip));
-          case HInductionVarAnalysis::kNeg:  // second max!
-            return SubValue(Value(0), GetMax(info->op_b, trip));
+            return AddValue(GetVal(info->op_a, trip, is_min),
+                            GetVal(info->op_b, trip, is_min));
+          case HInductionVarAnalysis::kSub:  // second reversed!
+            return SubValue(GetVal(info->op_a, trip, is_min),
+                            GetVal(info->op_b, trip, !is_min));
+          case HInductionVarAnalysis::kNeg:  // second reversed!
+            return SubValue(Value(0),
+                            GetVal(info->op_b, trip, !is_min));
           case HInductionVarAnalysis::kMul:
-            return GetMul(info->op_a, info->op_b, trip, true);
+            return GetMul(info->op_a, info->op_b, trip, is_min);
           case HInductionVarAnalysis::kDiv:
-            return GetDiv(info->op_a, info->op_b, trip, true);
+            return GetDiv(info->op_a, info->op_b, trip, is_min);
           case HInductionVarAnalysis::kFetch:
-            return GetFetch(info->fetch, trip, true);
+            return GetFetch(info->fetch, trip, is_min);
         }
         break;
       case HInductionVarAnalysis::kLinear:
-        // Minimum over linear induction a * i + b, for normalized 0 <= i < TC.
-        return AddValue(GetMul(info->op_a, trip, trip, true), GetMin(info->op_b, trip));
+        // Linear induction a * i + b, for normalized 0 <= i < TC.
+        return AddValue(GetMul(info->op_a, trip, trip, is_min),
+                        GetVal(info->op_b, trip, is_min));
       case HInductionVarAnalysis::kWrapAround:
       case HInductionVarAnalysis::kPeriodic:
-        // Minimum over all values in the wrap-around/periodic.
-        return MinValue(GetMin(info->op_a, trip), GetMin(info->op_b, trip));
-    }
-  }
-  return Value();
-}
-
-InductionVarRange::Value InductionVarRange::GetMax(HInductionVarAnalysis::InductionInfo* info,
-                                                   HInductionVarAnalysis::InductionInfo* trip) {
-  if (info != nullptr) {
-    switch (info->induction_class) {
-      case HInductionVarAnalysis::kInvariant:
-        // Invariants.
-        switch (info->operation) {
-          case HInductionVarAnalysis::kNop:    // normalized: TC - 1
-            DCHECK_EQ(info->op_a, info->op_b);
-            return SubValue(GetMax(info->op_b, trip), Value(1));
-          case HInductionVarAnalysis::kAdd:
-            return AddValue(GetMax(info->op_a, trip), GetMax(info->op_b, trip));
-          case HInductionVarAnalysis::kSub:  // second min!
-            return SubValue(GetMax(info->op_a, trip), GetMin(info->op_b, trip));
-          case HInductionVarAnalysis::kNeg:  // second min!
-            return SubValue(Value(0), GetMin(info->op_b, trip));
-          case HInductionVarAnalysis::kMul:
-            return GetMul(info->op_a, info->op_b, trip, false);
-          case HInductionVarAnalysis::kDiv:
-            return GetDiv(info->op_a, info->op_b, trip, false);
-          case HInductionVarAnalysis::kFetch:
-            return GetFetch(info->fetch, trip, false);
-        }
-        break;
-      case HInductionVarAnalysis::kLinear:
-        // Maximum over linear induction a * i + b, for normalized 0 <= i < TC.
-        return AddValue(GetMul(info->op_a, trip, trip, false), GetMax(info->op_b, trip));
-      case HInductionVarAnalysis::kWrapAround:
-      case HInductionVarAnalysis::kPeriodic:
-        // Maximum over all values in the wrap-around/periodic.
-        return MaxValue(GetMax(info->op_a, trip), GetMax(info->op_b, trip));
+        // Merge values in the wrap-around/periodic.
+        return MergeVal(GetVal(info->op_a, trip, is_min),
+                        GetVal(info->op_b, trip, is_min), is_min);
     }
   }
   return Value();
@@ -226,10 +199,10 @@
                                                    HInductionVarAnalysis::InductionInfo* info2,
                                                    HInductionVarAnalysis::InductionInfo* trip,
                                                    bool is_min) {
-  Value v1_min = GetMin(info1, trip);
-  Value v1_max = GetMax(info1, trip);
-  Value v2_min = GetMin(info2, trip);
-  Value v2_max = GetMax(info2, trip);
+  Value v1_min = GetVal(info1, trip, /* is_min */ true);
+  Value v1_max = GetVal(info1, trip, /* is_min */ false);
+  Value v2_min = GetVal(info2, trip, /* is_min */ true);
+  Value v2_max = GetVal(info2, trip, /* is_min */ false);
   if (v1_min.is_known && v1_min.a_constant == 0 && v1_min.b_constant >= 0) {
     // Positive range vs. positive or negative range.
     if (v2_min.is_known && v2_min.a_constant == 0 && v2_min.b_constant >= 0) {
@@ -256,10 +229,10 @@
                                                    HInductionVarAnalysis::InductionInfo* info2,
                                                    HInductionVarAnalysis::InductionInfo* trip,
                                                    bool is_min) {
-  Value v1_min = GetMin(info1, trip);
-  Value v1_max = GetMax(info1, trip);
-  Value v2_min = GetMin(info2, trip);
-  Value v2_max = GetMax(info2, trip);
+  Value v1_min = GetVal(info1, trip, /* is_min */ true);
+  Value v1_max = GetVal(info1, trip, /* is_min */ false);
+  Value v2_min = GetVal(info2, trip, /* is_min */ true);
+  Value v2_max = GetVal(info2, trip, /* is_min */ false);
   if (v1_min.is_known && v1_min.a_constant == 0 && v1_min.b_constant >= 0) {
     // Positive range vs. positive or negative range.
     if (v2_min.is_known && v2_min.a_constant == 0 && v2_min.b_constant >= 0) {
@@ -334,19 +307,12 @@
   return Value();
 }
 
-InductionVarRange::Value InductionVarRange::MinValue(Value v1, Value v2) {
+InductionVarRange::Value InductionVarRange::MergeVal(Value v1, Value v2, bool is_min) {
   if (v1.is_known && v2.is_known) {
     if (v1.instruction == v2.instruction && v1.a_constant == v2.a_constant) {
-      return Value(v1.instruction, v1.a_constant, std::min(v1.b_constant, v2.b_constant));
-    }
-  }
-  return Value();
-}
-
-InductionVarRange::Value InductionVarRange::MaxValue(Value v1, Value v2) {
-  if (v1.is_known && v2.is_known) {
-    if (v1.instruction == v2.instruction && v1.a_constant == v2.a_constant) {
-      return Value(v1.instruction, v1.a_constant, std::max(v1.b_constant, v2.b_constant));
+      return Value(v1.instruction, v1.a_constant,
+                   is_min ? std::min(v1.b_constant, v2.b_constant)
+                          : std::max(v1.b_constant, v2.b_constant));
     }
   }
   return Value();
diff --git a/compiler/optimizing/induction_var_range.h b/compiler/optimizing/induction_var_range.h
index 96cbd46..8280c8b 100644
--- a/compiler/optimizing/induction_var_range.h
+++ b/compiler/optimizing/induction_var_range.h
@@ -79,10 +79,9 @@
                         HInductionVarAnalysis::InductionInfo* trip,
                         bool is_min);
 
-  static Value GetMin(HInductionVarAnalysis::InductionInfo* info,
-                      HInductionVarAnalysis::InductionInfo* trip);
-  static Value GetMax(HInductionVarAnalysis::InductionInfo* info,
-                      HInductionVarAnalysis::InductionInfo* trip);
+  static Value GetVal(HInductionVarAnalysis::InductionInfo* info,
+                      HInductionVarAnalysis::InductionInfo* trip,
+                      bool is_min);
   static Value GetMul(HInductionVarAnalysis::InductionInfo* info1,
                       HInductionVarAnalysis::InductionInfo* info2,
                       HInductionVarAnalysis::InductionInfo* trip,
@@ -96,8 +95,7 @@
   static Value SubValue(Value v1, Value v2);
   static Value MulValue(Value v1, Value v2);
   static Value DivValue(Value v1, Value v2);
-  static Value MinValue(Value v1, Value v2);
-  static Value MaxValue(Value v1, Value v2);
+  static Value MergeVal(Value v1, Value v2, bool is_min);
 
   /** Results of prior induction variable analysis. */
   HInductionVarAnalysis *induction_analysis_;
diff --git a/compiler/optimizing/induction_var_range_test.cc b/compiler/optimizing/induction_var_range_test.cc
index c8abe36..5d9a075 100644
--- a/compiler/optimizing/induction_var_range_test.cc
+++ b/compiler/optimizing/induction_var_range_test.cc
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include <limits.h>
-
 #include "base/arena_allocator.h"
 #include "builder.h"
 #include "gtest/gtest.h"
@@ -114,12 +112,12 @@
 
   Value GetMin(HInductionVarAnalysis::InductionInfo* info,
                HInductionVarAnalysis::InductionInfo* induc) {
-    return InductionVarRange::GetMin(info, induc);
+    return InductionVarRange::GetVal(info, induc, /* is_min */ true);
   }
 
   Value GetMax(HInductionVarAnalysis::InductionInfo* info,
                HInductionVarAnalysis::InductionInfo* induc) {
-    return InductionVarRange::GetMax(info, induc);
+    return InductionVarRange::GetVal(info, induc, /* is_min */ false);
   }
 
   Value GetMul(HInductionVarAnalysis::InductionInfo* info1,
@@ -138,8 +136,8 @@
   Value SubValue(Value v1, Value v2) { return InductionVarRange::SubValue(v1, v2); }
   Value MulValue(Value v1, Value v2) { return InductionVarRange::MulValue(v1, v2); }
   Value DivValue(Value v1, Value v2) { return InductionVarRange::DivValue(v1, v2); }
-  Value MinValue(Value v1, Value v2) { return InductionVarRange::MinValue(v1, v2); }
-  Value MaxValue(Value v1, Value v2) { return InductionVarRange::MaxValue(v1, v2); }
+  Value MinValue(Value v1, Value v2) { return InductionVarRange::MergeVal(v1, v2, true); }
+  Value MaxValue(Value v1, Value v2) { return InductionVarRange::MergeVal(v1, v2, false); }
 
   // General building fields.
   ArenaPool pool_;
@@ -288,8 +286,9 @@
   ExpectEqual(Value(), AddValue(Value(&x_, 1, 5), Value(&y_, 1, -7)));
   ExpectEqual(Value(&x_, 1, 23), AddValue(Value(&x_, 1, 20), Value(3)));
   ExpectEqual(Value(&y_, 1, 5), AddValue(Value(55), Value(&y_, 1, -50)));
-  ExpectEqual(Value(INT_MAX), AddValue(Value(INT_MAX - 5), Value(5)));
-  ExpectEqual(Value(), AddValue(Value(INT_MAX - 5), Value(6)));  // unsafe
+  const int32_t max_value = std::numeric_limits<int32_t>::max();
+  ExpectEqual(Value(max_value), AddValue(Value(max_value - 5), Value(5)));
+  ExpectEqual(Value(), AddValue(Value(max_value - 5), Value(6)));  // unsafe
 }
 
 TEST_F(InductionVarRangeTest, SubValue) {
@@ -299,8 +298,9 @@
   ExpectEqual(Value(), SubValue(Value(&x_, 1, 5), Value(&y_, 1, -7)));
   ExpectEqual(Value(&x_, 1, 17), SubValue(Value(&x_, 1, 20), Value(3)));
   ExpectEqual(Value(&y_, -4, 105), SubValue(Value(55), Value(&y_, 4, -50)));
-  ExpectEqual(Value(INT_MIN), SubValue(Value(INT_MIN + 5), Value(5)));
-  ExpectEqual(Value(), SubValue(Value(INT_MIN + 5), Value(6)));  // unsafe
+  const int32_t min_value = std::numeric_limits<int32_t>::min();
+  ExpectEqual(Value(min_value), SubValue(Value(min_value + 5), Value(5)));
+  ExpectEqual(Value(), SubValue(Value(min_value + 5), Value(6)));  // unsafe
 }
 
 TEST_F(InductionVarRangeTest, MulValue) {