Cross Reference: /art/compiler/optimizing/bounds_check

Lines Matching refs:left
51   // Return whether (left + right) overflows or underflows.
52   static bool WouldAddOverflowOrUnderflow(int32_t left, int32_t right) {
56     if ((right > 0) && (left <= (std::numeric_limits<int32_t>::max() - right))) {
60     if ((right < 0) && (left >= (std::numeric_limits<int32_t>::min() - right))) {
75       HInstruction* left = bin_op->GetLeft();
81           instruction = left;
82           left_so_far = left;
100     HInstruction *left;
102     if (IsAddOrSubAConstant(instruction, &left, &right)) {
103       return ValueBound(left, right);
122     HInstruction *left;
124     if (IsAddOrSubAConstant(instruction, &left, &right)) {
125       if (left->IsArrayLength()) {
127         return ValueBound(left, right);
627                                               HInstruction* left,
632     DCHECK(left->IsLoopHeaderPhi());
634     if (instruction->GetBlock() != left->GetBlock()) {
662         // We don't handle '=='/'!=' test in case left and right can cross and
675           ApplyRangeFromComparison(left, instruction->GetBlock(), successor,
691   // Handle "if (left cmp_cond right)".
692   void HandleIf(HIf* instruction, HInstruction* left, HInstruction* right, IfCondition cond) {
703     ValueRange* left_range = LookupValueRange(left, block);
720     // for the left hand side.
730             HandleIfBetweenTwoMonotonicValueRanges(instruction, left, right, cond,
754         ApplyRangeFromComparison(left, block, true_successor, new_range);
766         ApplyRangeFromComparison(left, block, false_successor, new_range);
778         ApplyRangeFromComparison(left, block, true_successor, new_range);
789         ApplyRangeFromComparison(left, block, false_successor, new_range);
792       if (left->IsArrayLength()) {
800                 left, block, cond == kCondEQ ? true_successor : false_successor, new_range);
809                 left, block, cond == kCondEQ ? false_successor : true_successor, new_range);
818             left, block, cond == kCondEQ ? true_successor : false_successor, new_range);
953       HInstruction *left;
955       if (ValueBound::IsAddOrSubAConstant(instruction, &left, &increment)) {
956         if (left == phi) {
1017     HInstruction* left = sub->GetLeft();
1020       ValueRange* left_range = LookupValueRange(left, sub->GetBlock());
1036     HInstruction* left_of_left;  // left input of left.
1038     if (ValueBound::IsAddOrSubAConstant(left, &left_of_left, &right_const)) {
1039       left = left_of_left;
1041     // The value of left input of the sub equals (left + right_const).
1043     if (left->IsArrayLength()) {
1044       HInstruction* array_length = left->AsArrayLength();
1092     HInstruction* left = instruction->GetLeft();
1093     HInstruction* left_of_left;  // left input of left.
1095     if (ValueBound::IsAddOrSubAConstant(left, &left_of_left, &c)) {
1096       left = left_of_left;
1098     // The value of left input of instruction equals (left + c).
1103     if (left->IsArrayLength() && c <= 1) {
1105         // Make sure for unsigned shift, left side is not negative.
1113           ValueBound(left, 0));
1146     HInstruction* left = instruction->GetLeft();
1167       ValueRange* left_range = LookupValueRange(left, instruction->GetBlock());
1196       ValueRange* left_range = LookupValueRange(left, instruction->GetBlock());
1208       HInstruction *left;
1210       if (ValueBound::IsAddOrSubAConstant(len, &left, &right_const)) {
1211         // (left + right_const) is used as size to new the array.
1212         // We record "-right_const <= left <= new_array - right_const";
1219         ValueRange* existing_range = LookupValueRange(left, new_array->GetBlock());
1223         AssignRange(new_array->GetBlock(), left, range);