Cross Reference: /art/compiler/optimizing/bounds_check

Lines Matching refs:left
50   // Return whether (left + right) overflows or underflows.
51   static bool WouldAddOverflowOrUnderflow(int32_t left, int32_t right) {
55     if ((right > 0) && (left <= (std::numeric_limits<int32_t>::max() - right))) {
59     if ((right < 0) && (left >= (std::numeric_limits<int32_t>::min() - right))) {
74       HInstruction* left = bin_op->GetLeft();
80           instruction = left;
81           left_so_far = left;
99     HInstruction *left;
101     if (IsAddOrSubAConstant(instruction, &left, &right)) {
102       return ValueBound(left, right);
121     HInstruction *left;
123     if (IsAddOrSubAConstant(instruction, &left, &right)) {
124       if (left->IsArrayLength()) {
126         return ValueBound(left, right);
639                                               HInstruction* left,
644     DCHECK(left->IsLoopHeaderPhi());
646     if (instruction->GetBlock() != left->GetBlock()) {
674         // We don't handle '=='/'!=' test in case left and right can cross and
687           ApplyRangeFromComparison(left, instruction->GetBlock(), successor,
703   // Handle "if (left cmp_cond right)".
704   void HandleIf(HIf* instruction, HInstruction* left, HInstruction* right, IfCondition cond) {
715     ValueRange* left_range = LookupValueRange(left, block);
732     // for the left hand side.
742             HandleIfBetweenTwoMonotonicValueRanges(instruction, left, right, cond,
766         ApplyRangeFromComparison(left, block, true_successor, new_range);
778         ApplyRangeFromComparison(left, block, false_successor, new_range);
790         ApplyRangeFromComparison(left, block, true_successor, new_range);
801         ApplyRangeFromComparison(left, block, false_successor, new_range);
913       HInstruction *left;
915       if (ValueBound::IsAddOrSubAConstant(instruction, &left, &increment)) {
916         if (left == phi) {
961         HInstruction* left = cond->GetLeft();
963         HandleIf(instruction, left, right, cmp);
983     HInstruction* left = sub->GetLeft();
986       ValueRange* left_range = LookupValueRange(left, sub->GetBlock());
1002     HInstruction* left_of_left;  // left input of left.
1004     if (ValueBound::IsAddOrSubAConstant(left, &left_of_left, &right_const)) {
1005       left = left_of_left;
1007     // The value of left input of the sub equals (left + right_const).
1009     if (left->IsArrayLength()) {
1010       HInstruction* array_length = left->AsArrayLength();
1058     HInstruction* left = instruction->GetLeft();
1059     HInstruction* left_of_left;  // left input of left.
1061     if (ValueBound::IsAddOrSubAConstant(left, &left_of_left, &c)) {
1062       left = left_of_left;
1064     // The value of left input of instruction equals (left + c).
1069     if (left->IsArrayLength() && c <= 1) {
1071         // Make sure for unsigned shift, left side is not negative.
1079           ValueBound(left, 0));
1114       HInstruction *left;
1116       if (ValueBound::IsAddOrSubAConstant(len, &left, &right_const)) {
1117         // (left + right_const) is used as size to new the array.
1118         // We record "-right_const <= left <= new_array - right_const";
1126         ValueRange* existing_range = LookupValueRange(left, new_array->GetBlock());
1130         AssignRange(new_array->GetBlock(), left, range);