Fix broken build by removing more const qualifiers.

src/hydrogen-instructions.h

 // 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
@@ skipping 765 matching lines @@
       : HControlInstruction(true_target, false_target) {
     SetOperandAt(0, value);
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
-  HValue* value() const { return OperandAt(0); }
-  virtual int OperandCount() const { return 1; }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  HValue* value() { return OperandAt(0); }
+  virtual int OperandCount() { return 1; }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   DECLARE_INSTRUCTION(UnaryControlInstruction)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
  private:
   HOperandVector<1> operands_;
@@ skipping 56 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(AbnormalExit, "abnormal_exit")
 };
 
 
 class HUnaryOperation: public HInstruction {
  public:
   explicit HUnaryOperation(HValue* value) {
     SetOperandAt(0, value);
   }
 
-  HValue* value() const { return OperandAt(0); }
+  HValue* value() { return OperandAt(0); }
   virtual void PrintDataTo(StringStream* stream);
-  virtual int OperandCount() const { return 1; }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return 1; }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   DECLARE_INSTRUCTION(UnaryOperation)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
  private:
   HOperandVector<1> operands_;
@@ skipping 94 matching lines @@
   }
   bool HasAssignedIndexAt(int index) const {
     return assigned_indexes_[index] != kNoIndex;
   }
   void AddAssignedValue(int index, HValue* value) {
     AddValue(index, value);
   }
   void AddPushedValue(HValue* value) {
     AddValue(kNoIndex, value);
   }
-  virtual int OperandCount() const { return values_.length(); }
-  virtual HValue* OperandAt(int index) const { return values_[index]; }
+  virtual int OperandCount() { return values_.length(); }
+  virtual HValue* OperandAt(int index) { return values_[index]; }
 
   DECLARE_CONCRETE_INSTRUCTION(Simulate, "simulate")
 
 #ifdef DEBUG
   virtual void Verify();
 #endif
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     values_[index] = value;
@@ skipping 53 matching lines @@
 
 
 class HPushArgument: public HUnaryOperation {
  public:
   explicit HPushArgument(HValue* value) : HUnaryOperation(value) { }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
-  HValue* argument() const { return OperandAt(0); }
+  HValue* argument() { return OperandAt(0); }
 
   DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push_argument")
 };
 
 
 class HContext: public HInstruction {
  public:
   HContext() {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
@@ skipping 72 matching lines @@
 
 class HUnaryCall: public HCall {
  public:
   HUnaryCall(HValue* value, int argument_count)
       : HCall(argument_count), value_(NULL) {
     SetOperandAt(0, value);
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
-  HValue* value() const { return value_; }
+  HValue* value() { return value_; }
 
-  virtual int OperandCount() const { return 1; }
-  virtual HValue* OperandAt(int index) const {
+  virtual int OperandCount() { return 1; }
+  virtual HValue* OperandAt(int index) {
     ASSERT(index == 0);
     return value_;
   }
 
   DECLARE_INSTRUCTION(UnaryCall)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     ASSERT(index == 0);
     value_ = value;
@@ skipping 10 matching lines @@
       : HCall(argument_count) {
     SetOperandAt(0, first);
     SetOperandAt(1, second);
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   HValue* first() const { return operands_[0]; }
   HValue* second() const { return operands_[1]; }
 
-  virtual int OperandCount() const { return 2; }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return 2; }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   DECLARE_INSTRUCTION(BinaryCall)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
  private:
   HOperandVector<2> operands_;
@@ skipping 38 matching lines @@
 
 
 class HCallNamed: public HUnaryCall {
  public:
   HCallNamed(HValue* context, Handle<String> name, int argument_count)
       : HUnaryCall(context, argument_count), name_(name) {
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
-  HValue* context() const { return value(); }
+  HValue* context() { return value(); }
   Handle<String> name() const { return name_; }
 
   DECLARE_CONCRETE_INSTRUCTION(CallNamed, "call_named")
 
  private:
   Handle<String> name_;
 };
 
 
 class HCallFunction: public HUnaryCall {
  public:
   HCallFunction(HValue* context, int argument_count)
       : HUnaryCall(context, argument_count) {
   }
 
-  HValue* context() const { return value(); }
+  HValue* context() { return value(); }
 
   DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call_function")
 };
 
 
 class HCallGlobal: public HUnaryCall {
  public:
   HCallGlobal(HValue* context, Handle<String> name, int argument_count)
       : HUnaryCall(context, argument_count), name_(name) {
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
-  HValue* context() const { return value(); }
+  HValue* context() { return value(); }
   Handle<String> name() const { return name_; }
 
   DECLARE_CONCRETE_INSTRUCTION(CallGlobal, "call_global")
 
  private:
   Handle<String> name_;
 };
 
 
 class HCallKnownGlobal: public HCall {
@@ skipping 490 matching lines @@
     if (double_occurred) return Representation::Double();
     if (int32_occurred) return Representation::Integer32();
     return Representation::None();
   }
 
   virtual Range* InferRange();
   virtual Representation RequiredInputRepresentation(int index) const {
     return representation();
   }
   virtual HType CalculateInferredType();
-  virtual int OperandCount() const { return inputs_.length(); }
-  virtual HValue* OperandAt(int index) const { return inputs_[index]; }
-  HValue* GetRedundantReplacement() const;
+  virtual int OperandCount() { return inputs_.length(); }
+  virtual HValue* OperandAt(int index) { return inputs_[index]; }
+  HValue* GetRedundantReplacement();
   void AddInput(HValue* value);
 
   bool IsReceiver() { return merged_index_ == 0; }
 
   int merged_index() const { return merged_index_; }
 
   virtual const char* Mnemonic() const { return "phi"; }
 
   virtual void PrintTo(StringStream* stream);
 
@@ skipping 114 matching lines @@
 
 
 class HBinaryOperation: public HInstruction {
  public:
   HBinaryOperation(HValue* left, HValue* right) {
     ASSERT(left != NULL && right != NULL);
     SetOperandAt(0, left);
     SetOperandAt(1, right);
   }
 
-  HValue* left() const { return OperandAt(0); }
-  HValue* right() const { return OperandAt(1); }
+  HValue* left() { return OperandAt(0); }
+  HValue* right() { return OperandAt(1); }
 
   // TODO(kasperl): Move these helpers to the IA-32 Lithium
   // instruction sequence builder.
-  HValue* LeastConstantOperand() const {
+  HValue* LeastConstantOperand() {
     if (IsCommutative() && left()->IsConstant()) return right();
     return left();
   }
-  HValue* MostConstantOperand() const {
+  HValue* MostConstantOperand() {
     if (IsCommutative() && left()->IsConstant()) return left();
     return right();
   }
 
   virtual bool IsCommutative() const { return false; }
 
   virtual void PrintDataTo(StringStream* stream);
-  virtual int OperandCount() const { return operands_.length(); }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return operands_.length(); }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   DECLARE_INSTRUCTION(BinaryOperation)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
   HOperandVector<2> operands_;
 };
@@ skipping 13 matching lines @@
     SetAllSideEffects();
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     // The length is untagged, all other inputs are tagged.
     return (index == 2)
         ? Representation::Integer32()
         : Representation::Tagged();
   }
 
-  HValue* function() const { return OperandAt(0); }
-  HValue* receiver() const { return OperandAt(1); }
-  HValue* length() const { return OperandAt(2); }
-  HValue* elements() const { return OperandAt(3); }
+  HValue* function() { return OperandAt(0); }
+  HValue* receiver() { return OperandAt(1); }
+  HValue* length() { return OperandAt(2); }
+  HValue* elements() { return OperandAt(3); }
 
-  virtual int OperandCount() const { return operands_.length(); }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return operands_.length(); }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply_arguments")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
  private:
   HOperandVector<4> operands_;
@@ skipping 42 matching lines @@
 
   virtual void PrintDataTo(StringStream* stream);
 
   virtual Representation RequiredInputRepresentation(int index) const {
     // The arguments elements is considered tagged.
     return index == 0
         ? Representation::Tagged()
         : Representation::Integer32();
   }
 
-  HValue* arguments() const { return operands_[0]; }
-  HValue* length() const { return operands_[1]; }
-  HValue* index() const { return operands_[2]; }
+  HValue* arguments() { return operands_[0]; }
+  HValue* length() { return operands_[1]; }
+  HValue* index() { return operands_[2]; }
 
-  virtual int OperandCount() const { return operands_.length(); }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return operands_.length(); }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access_arguments_at")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
   virtual bool DataEquals(HValue* other) { return true; }
 
@@ skipping 12 matching lines @@
   virtual bool IsCheckInstruction() const { return true; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Integer32();
   }
 
 #ifdef DEBUG
   virtual void Verify();
 #endif
 
-  HValue* index() const { return left(); }
-  HValue* length() const { return right(); }
+  HValue* index() { return left(); }
+  HValue* length() { return right(); }
 
   DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds_check")
 
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 };
 
 
 class HBitwiseBinaryOperation: public HBinaryOperation {
  public:
@@ skipping 296 matching lines @@
 class HInstanceOf: public HInstruction {
  public:
   HInstanceOf(HValue* context, HValue* left, HValue* right) {
     SetOperandAt(0, context);
     SetOperandAt(1, left);
     SetOperandAt(2, right);
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
-  HValue* context() const { return operands_[0]; }
-  HValue* left() const { return operands_[1]; }
-  HValue* right() const { return operands_[2]; }
+  HValue* context() { return operands_[0]; }
+  HValue* left() { return operands_[1]; }
+  HValue* right() { return operands_[2]; }
 
   virtual bool EmitAtUses() const {
     return !HasSideEffects() && (uses()->length() <= 1);
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
-  virtual int OperandCount() const { return 3; }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return 3; }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance_of")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
  private:
   HOperandVector<3> operands_;
@@ skipping 268 matching lines @@
 class HCallStub: public HUnaryCall {
  public:
   HCallStub(HValue* context, CodeStub::Major major_key, int argument_count)
       : HUnaryCall(context, argument_count),
         major_key_(major_key),
         transcendental_type_(TranscendentalCache::kNumberOfCaches) {
   }
 
   CodeStub::Major major_key() { return major_key_; }
 
-  HValue* context() const { return value(); }
+  HValue* context() { return value(); }
 
   void set_transcendental_type(TranscendentalCache::Type transcendental_type) {
     transcendental_type_ = transcendental_type;
   }
   TranscendentalCache::Type transcendental_type() {
     return transcendental_type_;
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
@@ skipping 112 matching lines @@
 }
 
 
 class HStoreContextSlot: public HBinaryOperation {
  public:
   HStoreContextSlot(HValue* context, int slot_index, HValue* value)
       : HBinaryOperation(context, value), slot_index_(slot_index) {
     SetFlag(kChangesContextSlots);
   }
 
-  HValue* context() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
+  HValue* context() { return OperandAt(0); }
+  HValue* value() { return OperandAt(1); }
   int slot_index() const { return slot_index_; }
 
-  bool NeedsWriteBarrier() const {
+  bool NeedsWriteBarrier() {
     return StoringValueNeedsWriteBarrier(value());
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store_context_slot")
@@ skipping 11 matching lines @@
         offset_(offset) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     if (is_in_object) {
       SetFlag(kDependsOnInobjectFields);
     } else {
       SetFlag(kDependsOnBackingStoreFields);
     }
   }
 
-  HValue* object() const { return OperandAt(0); }
+  HValue* object() { return OperandAt(0); }
   bool is_in_object() const { return is_in_object_; }
   int offset() const { return offset_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
   virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load_named_field")
 
@@ skipping 10 matching lines @@
 
 
 class HLoadNamedGeneric: public HBinaryOperation {
  public:
   HLoadNamedGeneric(HValue* context, HValue* object, Handle<Object> name)
       : HBinaryOperation(context, object), name_(name) {
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
-  HValue* context() const { return OperandAt(0); }
-  HValue* object() const { return OperandAt(1); }
+  HValue* context() { return OperandAt(0); }
+  HValue* object() { return OperandAt(1); }
   Handle<Object> name() const { return name_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load_named_generic")
 
  private:
   Handle<Object> name_;
 };
 
 
 class HLoadFunctionPrototype: public HUnaryOperation {
  public:
   explicit HLoadFunctionPrototype(HValue* function)
       : HUnaryOperation(function) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetFlag(kDependsOnCalls);
   }
 
-  HValue* function() const { return OperandAt(0); }
+  HValue* function() { return OperandAt(0); }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load_function_prototype")
 
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 };
 
 
 class HLoadKeyed: public HBinaryOperation {
  public:
   HLoadKeyed(HValue* obj, HValue* key) : HBinaryOperation(obj, key) {
     set_representation(Representation::Tagged());
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
-  HValue* object() const { return OperandAt(0); }
-  HValue* key() const { return OperandAt(1); }
+  HValue* object() { return OperandAt(0); }
+  HValue* key() { return OperandAt(1); }
 
   DECLARE_INSTRUCTION(LoadKeyed)
 };
 
 
 class HLoadKeyedFastElement: public HLoadKeyed {
  public:
   HLoadKeyedFastElement(HValue* obj, HValue* key) : HLoadKeyed(obj, key) {
     SetFlag(kDependsOnArrayElements);
     SetFlag(kUseGVN);
@@ skipping 26 matching lines @@
 
   virtual void PrintDataTo(StringStream* stream);
 
   virtual Representation RequiredInputRepresentation(int index) const {
     // The key is supposed to be Integer32, but the base pointer
     // for the element load is a naked pointer.
     return (index == 1) ? Representation::Integer32()
         : Representation::External();
   }
 
-  HValue* external_pointer() const { return OperandAt(0); }
-  HValue* key() const { return OperandAt(1); }
+  HValue* external_pointer() { return OperandAt(0); }
+  HValue* key() { return OperandAt(1); }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadPixelArrayElement,
                                "load_pixel_array_element")
 
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 };
 
 
 class HLoadKeyedGeneric: public HLoadKeyed {
  public:
   HLoadKeyedGeneric(HContext* context, HValue* obj, HValue* key)
       : HLoadKeyed(obj, key), context_(NULL) {
     SetOperandAt(2, context);
     SetAllSideEffects();
   }
 
   HValue* context() const { return context_; }
-  HValue* object() const { return operands_[0]; }
-  HValue* key() const { return operands_[1]; }
+  HValue* object() { return operands_[0]; }
+  HValue* key() { return operands_[1]; }
 
-  virtual int OperandCount() const { return 3; }
-  virtual HValue* OperandAt(int index) const {
+  virtual int OperandCount() { return 3; }
+  virtual HValue* OperandAt(int index) {
     return (index < 2) ? operands_[index] : context_;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load_keyed_generic")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value);
 
  private:
   HValue* context_;
 };
 
 
 class HStoreNamed: public HBinaryOperation {
  public:
   HStoreNamed(HValue* obj, Handle<String> name, HValue* val)
       : HBinaryOperation(obj, val), name_(name) {
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
-  HValue* object() const { return OperandAt(0); }
+  HValue* object() { return OperandAt(0); }
   Handle<String> name() const { return name_; }
-  HValue* value() const { return OperandAt(1); }
+  HValue* value() { return OperandAt(1); }
   void set_value(HValue* value) { SetOperandAt(1, value); }
 
   DECLARE_INSTRUCTION(StoreNamed)
 
  private:
   Handle<String> name_;
 };
 
 
 class HStoreNamedField: public HStoreNamed {
@@ skipping 18 matching lines @@
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
   virtual void PrintDataTo(StringStream* stream);
 
   bool is_in_object() const { return is_in_object_; }
   int offset() const { return offset_; }
   Handle<Map> transition() const { return transition_; }
   void set_transition(Handle<Map> map) { transition_ = map; }
 
-  bool NeedsWriteBarrier() const {
+  bool NeedsWriteBarrier() {
     return StoringValueNeedsWriteBarrier(value());
   }
 
  private:
   bool is_in_object_;
   int offset_;
   Handle<Map> transition_;
 };
 
 
 class HStoreNamedGeneric: public HStoreNamed {
  public:
   HStoreNamedGeneric(HValue* context,
                      HValue* object,
                      Handle<String> name,
                      HValue* value)
       : HStoreNamed(object, name, value), context_(NULL) {
     SetOperandAt(2, context);
     SetAllSideEffects();
   }
 
   HValue* context() const { return context_; }
   HValue* object() const { return operands_[0]; }
   HValue* value() const { return operands_[1]; }
 
-  virtual int OperandCount() const { return 3; }
+  virtual int OperandCount() { return 3; }
 
-  virtual HValue* OperandAt(int index) const {
+  virtual HValue* OperandAt(int index) {
     return (index < 2) ? operands_[index] : context_;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store_named_generic")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value);
 
  private:
   HValue* context_;
 };
 
 
 class HStoreKeyed: public HInstruction {
  public:
   HStoreKeyed(HValue* obj, HValue* key, HValue* val) {
     SetOperandAt(0, obj);
     SetOperandAt(1, key);
     SetOperandAt(2, val);
   }
 
   virtual void PrintDataTo(StringStream* stream);
-  virtual int OperandCount() const { return operands_.length(); }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return operands_.length(); }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
-  HValue* object() const { return OperandAt(0); }
-  HValue* key() const { return OperandAt(1); }
-  HValue* value() const { return OperandAt(2); }
+  HValue* object() { return OperandAt(0); }
+  HValue* key() { return OperandAt(1); }
+  HValue* value() { return OperandAt(2); }
 
-  bool NeedsWriteBarrier() const {
+  bool NeedsWriteBarrier() {
     return StoringValueNeedsWriteBarrier(value());
   }
 
   DECLARE_INSTRUCTION(StoreKeyed)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
@@ skipping 22 matching lines @@
 class HStorePixelArrayElement: public HInstruction {
  public:
   HStorePixelArrayElement(HValue* external_elements, HValue* key, HValue* val) {
     SetFlag(kChangesPixelArrayElements);
     SetOperandAt(0, external_elements);
     SetOperandAt(1, key);
     SetOperandAt(2, val);
   }
 
   virtual void PrintDataTo(StringStream* stream);
-  virtual int OperandCount() const { return operands_.length(); }
-  virtual HValue* OperandAt(int index) const { return operands_[index]; }
+  virtual int OperandCount() { return operands_.length(); }
+  virtual HValue* OperandAt(int index) { return operands_[index]; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     if (index == 0) {
       return Representation::External();
     } else {
       return Representation::Integer32();
     }
   }
 
-  HValue* external_pointer() const { return operands_[0]; }
-  HValue* key() const { return operands_[1]; }
-  HValue* value() const { return operands_[2]; }
+  HValue* external_pointer() { return operands_[0]; }
+  HValue* key() { return operands_[1]; }
+  HValue* value() { return operands_[2]; }
 
   DECLARE_CONCRETE_INSTRUCTION(StorePixelArrayElement,
                                "store_pixel_array_element")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
 
   HOperandVector<3> operands_;
 };
 
 
 class HStoreKeyedGeneric: public HStoreKeyed {
  public:
   HStoreKeyedGeneric(HValue* context,
                      HValue* object,
                      HValue* key,
                      HValue* value)
       : HStoreKeyed(object, key, value), context_(NULL) {
     SetOperandAt(3, context);
     SetAllSideEffects();
   }
 
-  HValue* context() const { return context_; }
-  HValue* object() const { return operands_[0]; }
-  HValue* key() const { return operands_[1]; }
-  HValue* value() const { return operands_[2]; }
+  HValue* context() { return context_; }
+  HValue* object() { return operands_[0]; }
+  HValue* key() { return operands_[1]; }
+  HValue* value() { return operands_[2]; }
 
-  virtual int OperandCount() const { return 4; }
+  virtual int OperandCount() { return 4; }
 
-  virtual HValue* OperandAt(int index) const {
+  virtual HValue* OperandAt(int index) {
     return (index < 3) ? operands_[index] : context_;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store_keyed_generic")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value);
 
  private:
   HValue* context_;
 };
 
 
 class HStringCharCodeAt: public HBinaryOperation {
  public:
   HStringCharCodeAt(HValue* string, HValue* index)
       : HBinaryOperation(string, index) {
     set_representation(Representation::Integer32());
     SetFlag(kUseGVN);
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     // The index is supposed to be Integer32.
     return (index == 1) ? Representation::Integer32()
         : Representation::Tagged();
   }
 
-  HValue* string() const { return OperandAt(0); }
-  HValue* index() const { return OperandAt(1); }
+  HValue* string() { return OperandAt(0); }
+  HValue* index() { return OperandAt(1); }
 
   DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string_char_code_at")
 
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 
   virtual Range* InferRange() {
     return new Range(0, String::kMaxUC16CharCode);
   }
 };
@@ skipping 80 matching lines @@
         fast_elements_(fast_elements) {
     SetOperandAt(0, context);
   }
 
   HValue* context() const { return context_; }
   Handle<FixedArray> constant_properties() const {
     return constant_properties_;
   }
   bool fast_elements() const { return fast_elements_; }
 
-  virtual int OperandCount() const { return 1; }
-  virtual HValue* OperandAt(int index) const { return context_; }
+  virtual int OperandCount() { return 1; }
+  virtual HValue* OperandAt(int index) { return context_; }
 
   DECLARE_CONCRETE_INSTRUCTION(ObjectLiteral, "object_literal")
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     context_ = value;
   }
 
  private:
   HValue* context_;
@@ skipping 71 matching lines @@
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(DeleteProperty, "delete_property")
 
-  HValue* object() const { return left(); }
-  HValue* key() const { return right(); }
+  HValue* object() { return left(); }
+  HValue* key() { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_