Inline isUint32() method from HConstant, which was only used in one place.

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 630 matching lines @@
 bool HValue::IsInteger32Constant() {
   return IsConstant() && HConstant::cast(this)->HasInteger32Value();
 }
 
 
 int32_t HValue::GetInteger32Constant() {
   return HConstant::cast(this)->Integer32Value();
 }
 
 
+bool HValue::EqualsInteger32Constant(int32_t value) {
+  return IsConstant()
+    && HConstant::cast(this)->HasInteger32Value()
+    && HConstant::cast(this)->Integer32Value() == value;

[Sven Panne, 2013/04/18 09:46:23]

Use a combination of IsInteger32Constant and GetInteger32Constant above.

+}
+
+
 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 725 matching lines @@
   object()->PrintNameTo(stream);
   stream->Add(" ");
   index()->PrintNameTo(stream);
 }
 
 
 HValue* HBitwise::Canonicalize() {
   if (!representation().IsInteger32()) return this;
   // If x is an int32, then x & -1 == x, x | 0 == x and x ^ 0 == x.
   int32_t nop_constant = (op() == Token::BIT_AND) ? -1 : 0;
-  if (left()->IsConstant() &&
-      HConstant::cast(left())->HasInteger32Value() &&
-      HConstant::cast(left())->Integer32Value() == nop_constant &&
+  if (left()->EqualsInteger32Constant(nop_constant) &&
       !right()->CheckFlag(kUint32)) {
     return right();
   }
-  if (right()->IsConstant() &&
-      HConstant::cast(right())->HasInteger32Value() &&
-      HConstant::cast(right())->Integer32Value() == nop_constant &&
+  if (right()->EqualsInteger32Constant(nop_constant) &&
       !left()->CheckFlag(kUint32)) {
     return left();
   }
   return this;
 }
 
 
 HValue* HBitNot::Canonicalize() {
   // Optimize ~~x, a common pattern used for ToInt32(x).
   if (value()->IsBitNot()) {
@@ skipping 17 matching lines @@
 HValue* HSub::Canonicalize() {
   if (!representation().IsInteger32()) return this;
   if (CheckUsesForFlag(kTruncatingToInt32)) ClearFlag(kCanOverflow);
   return this;
 }
 
 
 // TODO(svenpanne) Use this in other Canonicalize() functions.
 static bool IsIdentityOperation(HValue* arg1, HValue* arg2, int32_t identity) {
   return arg1->representation().IsSpecialization() &&
-      arg2->IsInteger32Constant() &&
-      arg2->GetInteger32Constant() == identity;
+    arg2->EqualsInteger32Constant(identity);
 }
 
 
 HValue* HMul::Canonicalize() {
   if (IsIdentityOperation(left(), right(), 1)) return left();
   if (IsIdentityOperation(right(), left(), 1)) return right();
   return this;
 }
 
 
@@ skipping 2131 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal