399   const HBasicBlock* context = instruction->GetBlock();  in ClassifyTrivial()  local
405     info = TransferAddSub(context,  in ClassifyTrivial()
412     info = TransferAddSub(context,  in ClassifyTrivial()
419     info = TransferNeg(context, loop, LookupInfo(loop, instruction->InputAt(0)), type);  in ClassifyTrivial()
421     info = TransferMul(context,  in ClassifyTrivial()
429       info = TransferMul(context,  in ClassifyTrivial()
637     const HBasicBlock* context,  in TransferAddSub()  argument
650       return CreateInvariantOp(context, loop, op, a, b);  // direct invariant  in TransferAddSub()
654       InductionInfo* new_a = TransferAddSub(context, loop, a->op_a, b->op_a, op, type);  in TransferAddSub()
655       InductionInfo* new_b = TransferAddSub(context, loop, a->op_b, b->op_b, op, type);  in TransferAddSub()
662       InductionInfo* new_b = TransferAddSub(context, loop, a, b->op_b, op, type);  in TransferAddSub()
664         new_a = TransferAddSub(context, loop, a, new_a, op, type);  in TransferAddSub()
666         new_a = TransferNeg(context, loop, new_a, type);  in TransferAddSub()
674       InductionInfo* new_b = TransferAddSub(context, loop, a->op_b, b, op, type);  in TransferAddSub()
676         new_a = TransferAddSub(context, loop, new_a, b, op, type);  in TransferAddSub()
687     const HBasicBlock* context,  in TransferNeg()  argument
697       return CreateInvariantOp(context, loop, kNeg, nullptr, a);  // direct invariant  in TransferNeg()
700       InductionInfo* new_a = TransferNeg(context, loop, a->op_a, type);  in TransferNeg()
701       InductionInfo* new_b = TransferNeg(context, loop, a->op_b, type);  in TransferNeg()
711     const HBasicBlock* context,  in TransferMul()  argument
723       return CreateInvariantOp(context, loop, kMul, a, b);  // direct invariant  in TransferMul()
727       InductionInfo* new_a = TransferMul(context, loop, a, b->op_a, type);  in TransferMul()
728       InductionInfo* new_b = TransferMul(context, loop, a, b->op_b, type);  in TransferMul()
735       InductionInfo* new_a = TransferMul(context, loop, a->op_a, b, type);  in TransferMul()
736       InductionInfo* new_b = TransferMul(context, loop, a->op_b, b, type);  in TransferMul()
823   const HBasicBlock* context = instruction->GetBlock();  in SolveAddSub()  local
832           return (op == kAdd) ? b : CreateInvariantOp(context, loop, kNeg, nullptr, b);  in SolveAddSub()
838             return CreateInvariantOp(context, loop, op, a, b);  in SolveAddSub()
848           InductionInfo* new_a = op == kAdd ? b : TransferNeg(context, loop, b, type);  in SolveAddSub()
873                                    CreateInvariantOp(context, loop, kSub, a, initial),  in SolveAddSub()
905       const HBasicBlock* context = instruction->GetBlock();  in SolveOp()  local
925                                  CreateInvariantOp(context, loop, kRem, initial, c),  in SolveOp()
932                                  CreateInvariantOp(context, loop, kXor, initial, c),  in SolveOp()
951   const HBasicBlock* context = instruction->GetBlock();  in SolveTest()  local
955   if (IsExact(context, loop, LookupInfo(loop, x), &value) && value == opposite_value) {  in SolveTest()
957   } else if (IsExact(context, loop, LookupInfo(loop, y), &value) && value == opposite_value) {  in SolveTest()
979     const HBasicBlock* context = conversion->GetBlock();  in SolveConversion()  local
982         IsAtLeast(context, loop, initial, &value) && value >= min &&  in SolveConversion()
983         IsAtMost(context, loop, initial, &value)  && value <= max) {  in SolveConversion()
1010       const HBasicBlock* context = condition->GetBlock();  in VisitControl()  local
1019         VisitCondition(context, loop, if_false, a, b, type, condition->GetOppositeCondition());  in VisitControl()
1021         VisitCondition(context, loop, if_true, a, b, type, condition->GetCondition());  in VisitControl()
1027 void HInductionVarAnalysis::VisitCondition(const HBasicBlock* context,  in VisitCondition()  argument
1037       case kCondLT: VisitCondition(context, loop, body, b, a, type, kCondGT); break;  in VisitCondition()
1038       case kCondLE: VisitCondition(context, loop, body, b, a, type, kCondGE); break;  in VisitCondition()
1039       case kCondGT: VisitCondition(context, loop, body, b, a, type, kCondLT); break;  in VisitCondition()
1040       case kCondGE: VisitCondition(context, loop, body, b, a, type, kCondLE); break;  in VisitCondition()
1041       case kCondNE: VisitCondition(context, loop, body, b, a, type, kCondNE); break;  in VisitCondition()
1051     if (!IsExact(context, loop, stride_expr, &stride_value)) {  in VisitCondition()
1059     if (cmp == kCondNE && RewriteBreakLoop(context, loop, body, stride_value, type)) {  in VisitCondition()
1066         ((stride_value == +1 && IsTaken(context, loop, lower_expr, upper_expr, kCondLE)) ||  in VisitCondition()
1067          (stride_value == -1 && IsTaken(context, loop, lower_expr, upper_expr, kCondGE)))) {  in VisitCondition()
1073         !FitsNarrowerControl(context, loop, lower_expr, upper_expr, stride_value, a->type, cmp)) {  in VisitCondition()
1081       VisitTripCount(context, loop, lower_expr, upper_expr, stride_expr, stride_value, type, cmp);  in VisitCondition()
1086 void HInductionVarAnalysis::VisitTripCount(const HBasicBlock* context,  in VisitTripCount()  argument
1121   const bool is_taken = IsTaken(context, loop, lower_expr, upper_expr, cmp);  in VisitTripCount()
1122   const bool is_finite = IsFinite(context, loop, upper_expr, stride_value, type, cmp);  in VisitTripCount()
1128       trip_count = CreateInvariantOp(context, loop, kSub, trip_count, CreateConstant(1, type));  in VisitTripCount()
1130       trip_count = CreateInvariantOp(context, loop, kAdd, trip_count, CreateConstant(1, type));  in VisitTripCount()
1133     trip_count = CreateInvariantOp(context, loop, kAdd, trip_count, stride_expr);  in VisitTripCount()
1135   trip_count = CreateInvariantOp(context, loop, kSub, trip_count, lower_expr);  in VisitTripCount()
1136   trip_count = CreateInvariantOp(context, loop, kDiv, trip_count, stride_expr);  in VisitTripCount()
1158   InductionInfo* taken_test = CreateInvariantOp(context, loop, op, lower_expr, upper_expr);  in VisitTripCount()
1163 bool HInductionVarAnalysis::IsTaken(const HBasicBlock* context,  in IsTaken()  argument
1172       return IsAtMost(context, loop, lower_expr, &lower_value)  in IsTaken()
1173           && IsAtLeast(context, loop, upper_expr, &upper_value)  in IsTaken()
1176       return IsAtMost(context, loop, lower_expr, &lower_value)  in IsTaken()
1177           && IsAtLeast(context, loop, upper_expr, &upper_value)  in IsTaken()
1180       return IsAtLeast(context, loop, lower_expr, &lower_value)  in IsTaken()
1181           && IsAtMost(context, loop, upper_expr, &upper_value)  in IsTaken()
1184       return IsAtLeast(context, loop, lower_expr, &lower_value)  in IsTaken()
1185           && IsAtMost(context, loop, upper_expr, &upper_value)  in IsTaken()
1193 bool HInductionVarAnalysis::IsFinite(const HBasicBlock* context,  in IsFinite()  argument
1206           (IsAtMost(context, loop, upper_expr, &value) && value <= (max - stride_value + 1));  in IsFinite()
1208       return (IsAtMost(context, loop, upper_expr, &value) && value <= (max - stride_value));  in IsFinite()
1211           (IsAtLeast(context, loop, upper_expr, &value) && value >= (min - stride_value - 1));  in IsFinite()
1213       return (IsAtLeast(context, loop, upper_expr, &value) && value >= (min - stride_value));  in IsFinite()
1220 bool HInductionVarAnalysis::FitsNarrowerControl(const HBasicBlock* context,  in FitsNarrowerControl()  argument
1239   return IsAtLeast(context, loop, lower_expr, &value) && value >= min &&  in FitsNarrowerControl()
1240          IsAtMost(context, loop, lower_expr, &value)  && value <= max &&  in FitsNarrowerControl()
1241          IsAtLeast(context, loop, upper_expr, &value) && value >= min &&  in FitsNarrowerControl()
1242          IsAtMost(context, loop, upper_expr, &value)  && value <= max;  in FitsNarrowerControl()
1245 bool HInductionVarAnalysis::RewriteBreakLoop(const HBasicBlock* context,  in RewriteBreakLoop()  argument
1266       !IsFinite(context, loop, LookupInfo(loop, upper), stride_value, type, cmp)) {  in RewriteBreakLoop()
1280   if (!IsTaken(context, loop, LookupInfo(loop, index)->op_b, LookupInfo(loop, upper), cmp) &&  in RewriteBreakLoop()
1354     const HBasicBlock* context,  in CreateSimplifiedInvariant()  argument
1364   if (IsExact(context, loop, a, &value)) {  in CreateSimplifiedInvariant()
1377         return CreateSimplifiedInvariant(context, loop, kNeg, nullptr, b);  in CreateSimplifiedInvariant()
1381   if (IsExact(context, loop, b, &value)) {  in CreateSimplifiedInvariant()
1394         return CreateSimplifiedInvariant(context, loop, kNeg, nullptr, a);  in CreateSimplifiedInvariant()
1400       return CreateSimplifiedInvariant(context, loop, kSub, a, b->op_b);  in CreateSimplifiedInvariant()
1402       return CreateSimplifiedInvariant(context, loop, kAdd, a, b->op_b);  in CreateSimplifiedInvariant()
1409       return CreateSimplifiedInvariant(context, loop, kSub, b->op_b, b->op_a);  in CreateSimplifiedInvariant()
1420   const HBasicBlock* context = instruction->GetBlock();  in GetShiftConstant()  local
1425     if (!IsAtLeast(context, loop, initial, &value) || value < 0) {  in GetShiftConstant()
1436   if (IsExact(context, loop, b, &value)) {  in GetShiftConstant()
1464 bool HInductionVarAnalysis::IsExact(const HBasicBlock* context,  in IsExact()  argument
1469   return range.IsConstant(context, loop, info, InductionVarRange::kExact, value);  in IsExact()
1472 bool HInductionVarAnalysis::IsAtMost(const HBasicBlock* context,  in IsAtMost()  argument
1477   return range.IsConstant(context, loop, info, InductionVarRange::kAtMost, value);  in IsAtMost()
1480 bool HInductionVarAnalysis::IsAtLeast(const HBasicBlock* context,  in IsAtLeast()  argument
1485   return range.IsConstant(context, loop, info, InductionVarRange::kAtLeast, value);  in IsAtLeast()