Allow esi to be an allocatable register on IA32.

src/hydrogen-instructions.cc

-// Copyright 2010 the V8 project authors. All rights reserved.
+// Copyright 2011 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
 //       with the distribution.
@@ skipping 262 matching lines @@
 }
 
 
 void HValue::SetOperandAt(int index, HValue* value) {
   ASSERT(value == NULL || !value->representation().IsNone());
   RegisterUse(index, value);
   InternalSetOperandAt(index, value);
 }
 
 
+void HLoadKeyedGeneric::InternalSetOperandAt(int index, HValue* value) {
+  if (index < 2) {
+    operands_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
+void HCallKeyed::InternalSetOperandAt(int index, HValue* value) {
+  // The key and all the arguments are stored in the base class's arguments_
+  // vector.  The context is in the object itself.  Ugly.
+  if (index <= argument_count()) {
+    arguments_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
+void HCallNamed::InternalSetOperandAt(int index, HValue* value) {
+  // The arguments are in the base class's arguments_ vector.  The context
+  // is in the object itself.
+  if (index < argument_count()) {
+    arguments_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
+void HCallFunction::InternalSetOperandAt(int index, HValue* value) {
+  // The arguments are in the base class's arguments_ vector.  The context
+  // is in the object itself.
+  if (index < argument_count()) {
+    arguments_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
+void HCallGlobal::InternalSetOperandAt(int index, HValue* value) {
+  // The arguments are in the base class's arguments_ vector.  The context
+  // is in the object itself.
+  if (index < argument_count()) {
+    arguments_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
+void HCallNew::InternalSetOperandAt(int index, HValue* value) {
+  // The arguments are in the base class's arguments_ vector.  The context
+  // is in the object itself.
+  if (index < argument_count()) {
+    arguments_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
+void HStoreKeyedGeneric::InternalSetOperandAt(int index, HValue* value) {
+  if (index < 3) {
+    operands_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
+void HStoreNamedGeneric::InternalSetOperandAt(int index, HValue* value) {
+  if (index < 2) {
+    operands_[index] = value;
+  } else {
+    context_ = value;
+  }
+}
+
+
 void HValue::ReplaceAndDelete(HValue* other) {
   ReplaceValue(other);
   Delete();
 }
 
 
 void HValue::ReplaceValue(HValue* other) {
   ZoneList<HValue*> start_uses(2);
   for (int i = 0; i < uses_.length(); ++i) {
     HValue* use = uses_.at(i);
@@ skipping 430 matching lines @@
   HCall::PrintDataTo(stream);
 }
 
 
 void HCallRuntime::PrintDataTo(StringStream* stream) const {
   SmartPointer<char> name_string = name()->ToCString();
   stream->Add("%s ", *name_string);
   HCall::PrintDataTo(stream);
 }
 
+
 void HCallStub::PrintDataTo(StringStream* stream) const {
-  stream->Add("%s(%d)",
+  HUnaryOperation::PrintDataTo(stream);
+  stream->Add(" %s(%d)",
               CodeStub::MajorName(major_key_, false),
               argument_count_);
 }
 
 
+void HInstanceOf::PrintDataTo(StringStream* stream) const {
+  left()->PrintNameTo(stream);
+  stream->Add(" ");
+  right()->PrintNameTo(stream);
+  stream->Add(" ");
+  context()->PrintNameTo(stream);
+}
+
+
 Range* HValue::InferRange() {
   if (representation().IsTagged()) {
     // Tagged values are always in int32 range when converted to integer,
     // but they can contain -0.
     Range* result = new Range();
     result->set_can_be_minus_zero(true);
     return result;
   } else if (representation().IsNone()) {
     return NULL;
   } else {
@@ skipping 706 matching lines @@
 
 
 void HCheckPrototypeMaps::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal