Suggestions for iDef infrastructure classes.

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 658 matching lines @@
 }
 
 
 void HValue::ComputeInitialRange(Zone* zone) {
   ASSERT(!HasRange());
   range_ = InferRange(zone);
   ASSERT(HasRange());
 }
 
 
+bool HValue::DecomposeValuePlusConstant(HValue** value, int32_t* constant) {
+  if (IsAdd()) {
+    HAdd* add = HAdd::cast(this);
+    if (add->right()->IsConstant() &&
+        HConstant::cast(add->right())->HasInteger32Value()) {
+      *value = add->left();
+      *constant = HConstant::cast(add->right())->Integer32Value();
+      return true;
+    } else if (add->left()->IsConstant() &&
+        HConstant::cast(add->left())->HasInteger32Value()) {
+      *value = add->right();
+      *constant = HConstant::cast(add->left())->Integer32Value();
+      return true;
+    }
+  } else if (IsSub()) {
+    HSub* sub = HSub::cast(this);
+    if (sub->right()->IsConstant() &&
+        HConstant::cast(sub->right())->HasInteger32Value()) {
+      *value = sub->left();
+      *constant = -HConstant::cast(sub->right())->Integer32Value();
+      return true;
+    }
+  }
+  *value = NULL;
+  *constant = 0;
+  return false;
+}
+
+
+HValue* HValue::InsertNumericConstraint(HInstruction* insertion_point,
+                                        NumericRelation relation,
+                                        HValue* other,
+                                        int32_t offset) {
+  return HNumericConstraint::New(
+      insertion_point, this, relation, other, offset);
+}
+
+
 void HInstruction::PrintTo(StringStream* stream) {
   PrintMnemonicTo(stream);
   PrintDataTo(stream);
   PrintRangeTo(stream);
   PrintChangesTo(stream);
   PrintTypeTo(stream);
 }
 
 
 void HInstruction::PrintMnemonicTo(StringStream* stream) {
@@ skipping 98 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(HInstruction* insertion_point,
+                                       HValue* input,
+                                       NumericRelation constraint,
+                                       HValue* value,
+                                       int delta)
+    : constraint_(constraint),
+      delta_(delta) {
+  SetOperandAt(0, input);
+  SetOperandAt(1, value);
+  set_representation(input->representation());
+  InsertAfter(insertion_point);
+}
+
+
+HNumericConstraint* HNumericConstraint::Create(
+    HInstruction* insertion_point,
+    HValue* input,
+    NumericRelation constraint,
+    HValue* value,
+    int delta) {
+  return new (previous_definition->block()->zone()) HNumericConstraint(

[Jakob Kummerow, 2013/02/04 17:06:09]

what's previous_definition?

+      insertion_point, input, constraint, value, delta);
+}
+
+
+HNumericConstraint* HNumericConstraint::New(
+    HInstruction* insertion_point,
+    HValue* input,
+    NumericRelation constraint,
+    HValue* value,
+    int delta) {
+  HNumericConstraint* result = Create(
+        insertion_point, input, constraint, value, delta);
+  AddImpliedConstraints(input, input, constraint, value, delta);
+  return result;
+}
+
+
+
+void HNumericConstraint::AddInformativeDefinitions() {}
+
+void HNumericConstraint::PrintDataTo(StringStream* stream) {
+  stream->Add("(");
+  input()->PrintNameTo(stream);
+  stream->Add(" %s ", constraint().Mnemonic());
+  value()->PrintNameTo(stream);
+  if (delta() > 0) {
+    stream->Add(" + %d", delta());
+  } else if (delta() < 0) {
+    stream->Add(" - %d", -delta());
+  }
+  stream->Add(")");
+}
+
+
+bool HNumericConstraint::CheckRelation(NumericRelation relation,
+                                       HValue* other,
+                                       int32_t offset) {
+  if (other == value() && relation.Includes(constraint(), offset, delta())) {

[Jakob Kummerow, 2013/02/04 17:06:09]

I don't see "Includes()" defined anywhere. Do you mean "Implies()"?
Also, more descriptive method name please. I'd like to be able to tell from the
method signature what it computes (does it check if "this->input() relation
other" holds, assuming "this->input() this->constraint() this->value()" is true?
Or the other way round?).

+    return true;
+  }
+  return input()->IsRelationTrue(relation, other, offset);

[Jakob Kummerow, 2013/02/04 17:06:09]

When you have two methods recursively calling each other, please put their
implementations next to each other so it's easier to see what's going on. Also,
I'm not convinced this recursive call terminates properly in all cases.

+}
+
+
 void HDummyUse::PrintDataTo(StringStream* stream) {
   value()->PrintNameTo(stream);
 }
 
 
 void HUnaryCall::PrintDataTo(StringStream* stream) {
   value()->PrintNameTo(stream);
   stream->Add(" ");
   stream->Add("#%d", argument_count());
 }
@@ skipping 2102 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal