Infrastructure classes for evaluating numeric relations between values.

src/hydrogen-instructions.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 506 matching lines @@
   switch (opcode()) {
 #define MAKE_CASE(type) case k##type: return #type;
     HYDROGEN_CONCRETE_INSTRUCTION_LIST(MAKE_CASE)
 #undef MAKE_CASE
     case kPhi: return "Phi";
     default: return "";
   }
 }
 
 
+bool HValue::IsInteger32Constant() {
+  return IsConstant() && HConstant::cast(this)->HasInteger32Value();
+}
+
+
+int32_t HValue::GetInteger32Constant() {
+  ASSERT(IsInteger32Constant());
+  return HConstant::cast(this)->Integer32Value();
+}
+
+
 void HValue::SetOperandAt(int index, HValue* value) {
   RegisterUse(index, value);
   InternalSetOperandAt(index, value);
 }
 
 
 void HValue::DeleteAndReplaceWith(HValue* other) {
   // We replace all uses first, so Delete can assert that there are none.
   if (other != NULL) ReplaceAllUsesWith(other);
   ASSERT(HasNoUses());
@@ skipping 146 matching lines @@
   PrintChangesTo(stream);
   PrintTypeTo(stream);
 }
 
 
 void HInstruction::PrintMnemonicTo(StringStream* stream) {
   stream->Add("%s ", Mnemonic());
 }
 
 
+HValue* HValue::AddNumericConstraint(HInstruction* insertion_point,
+                                     HValue* related_value,
+                                     NumericRelation relation) {
+  return HNumericConstraint::New(
+      insertion_point, this, related_value, relation);
+}
+
+
 void HInstruction::Unlink() {
   ASSERT(IsLinked());
   ASSERT(!IsControlInstruction());  // Must never move control instructions.
   ASSERT(!IsBlockEntry());  // Doesn't make sense to delete these.
   ASSERT(previous_ != NULL);
   previous_->next_ = next_;
   if (next_ == NULL) {
     ASSERT(block()->last() == this);
     block()->set_last(previous_);
   } else {
@@ skipping 84 matching lines @@
   }
 
   // Verify that instructions that can be eliminated by GVN have overridden
   // HValue::DataEquals.  The default implementation is UNREACHABLE.  We
   // don't actually care whether DataEquals returns true or false here.
   if (CheckFlag(kUseGVN)) DataEquals(this);
 }
 #endif
 
 
+HNumericConstraint* HNumericConstraint::New(HInstruction* insertion_point,
+                                            HValue* constrained_value,
+                                            HValue* related_value,
+                                            NumericRelation relation) {
+  HNumericConstraint* result =
+      new(insertion_point->block()->zone()) HNumericConstraint(
+          constrained_value, related_value, relation);
+  result->InsertAfter(insertion_point);
+  return result;
+}
+
+
+void HNumericConstraint::PrintDataTo(StringStream* stream) {
+  stream->Add("(");
+  constrained_value()->PrintNameTo(stream);
+  stream->Add(" %s ", relation().Mnemonic());
+  related_value()->PrintNameTo(stream);
+  stream->Add(")");
+}
+
+
 void HDummyUse::PrintDataTo(StringStream* stream) {
   value()->PrintNameTo(stream);
 }
 
 
 void HUnaryCall::PrintDataTo(StringStream* stream) {
   value()->PrintNameTo(stream);
   stream->Add(" ");
   stream->Add("#%d", argument_count());
 }
 
 
 void HBinaryCall::PrintDataTo(StringStream* stream) {
   first()->PrintNameTo(stream);
   stream->Add(" ");
   second()->PrintNameTo(stream);
   stream->Add(" ");
   stream->Add("#%d", argument_count());
 }
 
 
+bool HBoundsCheck::CheckRelation(NumericRelation relation,
+                                         HValue* related_value) {
+  if (related_value == length()) {
+    return NumericRelation::Lt().Implies(relation);
+  } else if (related_value == block()->graph()->GetConstant0()) {
+    return NumericRelation::Ge().Implies(relation);
+  } else {
+    return false;
+  }
+}
+
+
 void HBoundsCheck::PrintDataTo(StringStream* stream) {
   index()->PrintNameTo(stream);
   stream->Add(" ");
   length()->PrintNameTo(stream);
 }
 
 
 void HBoundsCheck::InferRepresentation(HInferRepresentation* h_infer) {
   ASSERT(CheckFlag(kFlexibleRepresentation));
   Representation r;
@@ skipping 640 matching lines @@
     if (!right()->range()->CanBeZero()) {
       ClearFlag(HValue::kCanBeDivByZero);
     }
     return result;
   } else {
     return HValue::InferRange(zone);
   }
 }
 
 
+void HPhi::AddInformativeDefinitions() {
+  HValue* induction_base = NULL;
+  NumericRelation relation = NumericRelation::None();
+  if (OperandCount() == 2) {
+    if (OperandAt(0)->IsRelationTrue(NumericRelation::Ge(), this)) {

[Jakob Kummerow, 2013/02/12 15:10:42]

I don't feel strongly about it, but you *could* avoid spelling out all these
cases explicitly:

static const NumericRelation[] relations = { NumericRelation::Ge(),
NumericRelation::Le() };
for (rel_i = 0; rel_i < 2; rel_i++) {
  NumericRelation rel = relations[rel_i];
  for (i = 0; i <= 1; i++) {
    if (Operand(i)->IsRelationTrue(relation, this)) {
      induction_base = OperandAt((i+1) % 2);
      relation = rel;
    }
  }
}

[Massi, 2013/02/13 11:56:42]

Done.

+      induction_base = OperandAt(1);
+      relation = NumericRelation::Ge();
+    } else if (OperandAt(0)->IsRelationTrue(NumericRelation::Le(), this)) {
+      induction_base = OperandAt(1);
+      relation = NumericRelation::Ge();

[Jakob Kummerow, 2013/02/12 15:10:42]

s/Ge/Le/

[Massi, 2013/02/13 11:56:42]

Done.

+    } else if (OperandAt(1)->IsRelationTrue(NumericRelation::Ge(), this)) {
+      induction_base = OperandAt(0);
+      relation = NumericRelation::Ge();
+    } else if (OperandAt(1)->IsRelationTrue(NumericRelation::Le(), this)) {
+      induction_base = OperandAt(0);
+      relation = NumericRelation::Ge();

[Jakob Kummerow, 2013/02/12 15:10:42]

s/Ge/Le/

[Massi, 2013/02/13 11:56:42]

Done.

+    }
+  }
+
+  if (induction_base == NULL) return;
+
+  AddNumericConstraint(block()->first(), induction_base, relation);
+}
+
+
 Range* HMathMinMax::InferRange(Zone* zone) {
   if (representation().IsInteger32()) {
     Range* a = left()->range();
     Range* b = right()->range();
     Range* res = a->Copy(zone);
     if (operation_ == kMathMax) {
       res->CombinedMax(b);
     } else {
       ASSERT(operation_ == kMathMin);
       res->CombinedMin(b);
@@ skipping 393 matching lines @@
         result->Sar(c->Integer32Value());
         result->set_can_be_minus_zero(false);
         return result;
       }
     }
   }
   return HValue::InferRange(zone);
 }
 
 
+bool HShr::CheckRelation(NumericRelation relation, HValue* other) {
+  if (right()->IsInteger32Constant()) {
+    HValue* base = left();
+    int32_t bits = right()->GetInteger32Constant();
+    if (relation.IsExtendable(-bits) &&
+        base->IsRelationTrue(NumericRelation::Ge(),
+                             block()->graph()->GetConstant0())) {
+      return base->IsRelationTrue(relation, other);
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
+
 Range* HShl::InferRange(Zone* zone) {
   if (right()->IsConstant()) {
     HConstant* c = HConstant::cast(right());
     if (c->HasInteger32Value()) {
       Range* result = (left()->range() != NULL)
           ? left()->range()->Copy(zone)
           : new(zone) Range();
       result->Shl(c->Integer32Value());
       result->set_can_be_minus_zero(false);
       return result;
     }
   }
   return HValue::InferRange(zone);
 }
 
 
+bool HShl::CheckRelation(NumericRelation relation, HValue* other) {
+  if (right()->IsInteger32Constant()) {
+    HValue* base = left();
+    int32_t bits = right()->GetInteger32Constant();
+    if (relation.IsExtendable(bits) &&
+        base->IsRelationTrue(NumericRelation::Ge(),
+                             block()->graph()->GetConstant0())) {
+      return base->IsRelationTrue(relation, other);
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+}
+
+
 Range* HLoadKeyed::InferRange(Zone* zone) {
   switch (elements_kind()) {
     case EXTERNAL_PIXEL_ELEMENTS:
       return new(zone) Range(0, 255);
     case EXTERNAL_BYTE_ELEMENTS:
       return new(zone) Range(-128, 127);
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
       return new(zone) Range(0, 255);
     case EXTERNAL_SHORT_ELEMENTS:
       return new(zone) Range(-32768, 32767);
@@ skipping 1024 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal