Replace InstanceSetterComp instruction with a plain instance call.

vm/intermediate_language.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 57 matching lines @@
   M(PolymorphicInstanceCall, PolymorphicInstanceCallComp)                      \
   M(StaticCall, StaticCallComp)                                                \
   M(LoadLocal, LoadLocalComp)                                                  \
   M(StoreLocal, StoreLocalComp)                                                \
   M(StrictCompare, StrictCompareComp)                                          \
   M(EqualityCompare, EqualityCompareComp)                                      \
   M(RelationalOp, RelationalOpComp)                                            \
   M(NativeCall, NativeCallComp)                                                \
   M(LoadIndexed, LoadIndexedComp)                                              \
   M(StoreIndexed, StoreIndexedComp)                                            \
-  M(InstanceSetter, InstanceSetterComp)                                        \
   M(LoadInstanceField, LoadInstanceFieldComp)                                  \
   M(StoreInstanceField, StoreInstanceFieldComp)                                \
   M(LoadStaticField, LoadStaticFieldComp)                                      \
   M(StoreStaticField, StoreStaticFieldComp)                                    \
   M(BooleanNegate, BooleanNegateComp)                                          \
   M(InstanceOf, InstanceOfComp)                                                \
   M(CreateArray, CreateArrayComp)                                              \
   M(CreateClosure, CreateClosureComp)                                          \
   M(AllocateObject, AllocateObjectComp)                                        \
   M(AllocateObjectWithBoundsCheck, AllocateObjectWithBoundsCheckComp)          \
@@ skipping 436 matching lines @@
         token_kind_(token_kind),
         arguments_(arguments),
         argument_names_(argument_names),
         checked_argument_count_(checked_argument_count) {
     ASSERT(function_name.IsZoneHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle());
     ASSERT(Token::IsBinaryToken(token_kind) ||
            Token::IsUnaryToken(token_kind) ||
            token_kind == Token::kGET ||
+           token_kind == Token::kSET ||
            token_kind == Token::kILLEGAL);
   }
 
   DECLARE_CALL_COMPUTATION(InstanceCall)
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
@@ skipping 331 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LoadInstanceFieldComp);
 };
 
 
 class StoreInstanceFieldComp : public TemplateComputation<2> {
  public:
   StoreInstanceFieldComp(const Field& field,
                          Value* instance,
                          Value* value,
-                         InstanceSetterComp* original)  // Maybe NULL.
+                         InstanceCallComp* original)  // Maybe NULL.
       : field_(field), original_(original) {
     ASSERT(instance != NULL);
     ASSERT(value != NULL);
     inputs_[0] = instance;
     inputs_[1] = value;
   }
 
   DECLARE_COMPUTATION(StoreInstanceField)
 
   const Field& field() const { return field_; }
 
   Value* instance() const { return inputs_[0]; }
   Value* value() const { return inputs_[1]; }
 
-  const InstanceSetterComp* original() const { return original_; }
+  const InstanceCallComp* original() const { return original_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
  private:
   const Field& field_;
-  const InstanceSetterComp* original_;  // For optimizations.
+  const InstanceCallComp* original_;  // For optimizations.
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldComp);
 };
 
 
 class LoadStaticFieldComp : public TemplateComputation<0> {
  public:
   explicit LoadStaticFieldComp(const Field& field) : field_(field) {}
 
   DECLARE_COMPUTATION(LoadStaticField);
@@ skipping 114 matching lines @@
 
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   ObjectKind receiver_type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedComp);
 };
 
 
-// TODO(fschneider): Make this an instance call.
-class InstanceSetterComp : public Computation {
- public:
-  InstanceSetterComp(intptr_t token_pos,
-                     intptr_t try_index,
-                     const String& field_name,
-                     ZoneGrowableArray<PushArgumentInstr*>* arguments)
-      : token_pos_(token_pos),
-        try_index_(try_index),
-        field_name_(field_name),
-        arguments_(arguments) { }
-
-  DECLARE_CALL_COMPUTATION(InstanceSetter)
-
-  intptr_t token_pos() const { return token_pos_; }
-  intptr_t try_index() const { return try_index_; }
-  const String& field_name() const { return field_name_; }
-
-  virtual intptr_t ArgumentCount() const { return arguments_->length(); }
-  PushArgumentInstr* ArgumentAt(intptr_t index) const {
-    return (*arguments_)[index];
-  }
-
-  virtual bool CanDeoptimize() const { return true; }
-
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
- private:
-  const intptr_t token_pos_;
-  const intptr_t try_index_;
-  const String& field_name_;
-  ZoneGrowableArray<PushArgumentInstr*>* arguments_;
-
-  DISALLOW_COPY_AND_ASSIGN(InstanceSetterComp);
-};
-
-
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateComp : public TemplateComputation<1> {
  public:
   explicit BooleanNegateComp(Value* value) {
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(BooleanNegate)
 
   Value* value() const { return inputs_[0]; }
@@ skipping 1698 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_