Fixed numeric relations on HPhi instances.

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 825 matching lines @@
 
 void HNumericConstraint::PrintDataTo(StringStream* stream) {
   stream->Add("(");
   constrained_value()->PrintNameTo(stream);
   stream->Add(" %s ", relation().Mnemonic());
   related_value()->PrintNameTo(stream);
   stream->Add(")");
 }
 
 
+HInductionVariableAnnotation* HInductionVariableAnnotation::AddToGraph(
+    HPhi* phi,
+    NumericRelation relation,
+    int operand_index) {
+  HInductionVariableAnnotation* result =
+      new(phi->block()->zone()) HInductionVariableAnnotation(phi, relation,
+                                                             operand_index);
+  result->InsertAfter(phi->block()->first());
+  return result;
+}
+
+
+void HInductionVariableAnnotation::PrintDataTo(StringStream* stream) {
+  stream->Add("(");
+  RedefinedOperand()->PrintNameTo(stream);
+  stream->Add(" %s ", relation().Mnemonic());
+  induction_base()->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());
 }
@@ skipping 691 matching lines @@
     }
     return result;
   } else {
     return HValue::InferRange(zone);
   }
 }
 
 
 void HPhi::AddInformativeDefinitions() {
   if (OperandCount() == 2) {
+    // If one of the operands is an OSR block give up (this cannot be an
+    // induction variable).
+    if (OperandAt(0)->block()->is_osr_entry() ||
+        OperandAt(1)->block()->is_osr_entry()) return;
+
     for (int operand_index = 0; operand_index < 2; operand_index++) {
       int other_operand_index = (operand_index + 1) % 2;
 
-      // Add an idef that "discards" the OSR entry block branch.
-      if (OperandAt(operand_index)->block()->is_osr_entry()) {
-        HNumericConstraint::AddToGraph(
-            this, NumericRelation::Eq(), OperandAt(other_operand_index));
-      }
-
       static NumericRelation relations[] = {
         NumericRelation::Ge(),
         NumericRelation::Le()
       };
 
       // Check if this phi is an induction variable. If, e.g., we know that
       // its first input is greater than the phi itself, then that must be
       // the back edge, and the phi is always greater than its second input.
       for (int relation_index = 0; relation_index < 2; relation_index++) {
         if (OperandAt(operand_index)->IsRelationTrue(relations[relation_index],
                                                      this)) {
-          HNumericConstraint::AddToGraph(this,
-                                         relations[relation_index],
-                                         OperandAt(other_operand_index));
+          HInductionVariableAnnotation::AddToGraph(this,
+                                                   relations[relation_index],
+                                                   other_operand_index);
         }
       }
     }
   }
 }
 
 
+bool HPhi::IsRelationTrueInternal(NumericRelation relation, HValue* other) {
+  if (CheckFlag(kNumericConstraintEvaluationInProgress)) return false;
+
+  SetFlag(kNumericConstraintEvaluationInProgress);
+  bool result = true;
+  for (int i = 0; i < OperandCount(); i++) {
+    // Skip OSR entry blocks
+    if (OperandAt(i)->block()->is_osr_entry()) continue;
+
+    if (!OperandAt(i)->IsRelationTrue(relation, other)) {
+      result = false;
+      break;
+    }
+  }
+  ClearFlag(kNumericConstraintEvaluationInProgress);
+
+  return result;
+}
+
+
 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 1463 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal