Split array loads/stores for growable arrays into two IL instructions.

runtime/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 949 matching lines @@
 
   bool has_propagated_cid() const { return propagated_cid_ != kIllegalCid; }
   intptr_t propagated_cid() const { return propagated_cid_; }
 
   // May compute and set propagated cid.
   virtual intptr_t GetPropagatedCid();
 
   // Returns true if the propagated cid has changed.
   bool SetPropagatedCid(intptr_t cid);
 
-  // Returns true if the definition may have side effects.
+  // Returns true if the definition is affected by side effects.
+  // Only instructions that are not affected by side effects can participate
+  // in redundancy elimination or loop invariant code motion.
   // TODO(fschneider): Make this abstract and implement for all definitions
   // instead of returning the safe default (true).
-  virtual bool HasSideEffect() const { return true; }
+  virtual bool AffectedBySideEffect() const { return true; }
 
   Value* input_use_list() { return input_use_list_; }
   void set_input_use_list(Value* head) { input_use_list_ = head; }
 
   Value* env_use_list() { return env_use_list_; }
   void set_env_use_list(Value* head) { env_use_list_ = head; }
 
   // Returns a replacement for the definition or NULL if the definition can
   // be eliminated.  By default returns the definition (input parameter)
   // which means no change.
@@ skipping 1237 matching lines @@
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldInstr);
 };
 
 
 class LoadIndexedInstr : public TemplateDefinition<2> {
  public:
   LoadIndexedInstr(Value* array, Value* index, intptr_t receiver_type)
       : receiver_type_(receiver_type) {
+    ASSERT(receiver_type == kArrayCid ||
+           receiver_type == kImmutableArrayCid ||
+           receiver_type == kGrowableObjectArrayCid);
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
   }
 
   DECLARE_INSTRUCTION(LoadIndexed)
   virtual RawAbstractType* CompileType() const;
 
   Value* array() const { return inputs_[0]; }
@@ skipping 11 matching lines @@
 };
 
 
 class StoreIndexedInstr : public TemplateDefinition<3> {
  public:
   StoreIndexedInstr(Value* array,
                     Value* index,
                     Value* value,
                     intptr_t receiver_type)
         : receiver_type_(receiver_type) {
+    ASSERT(receiver_type == kArrayCid ||
+           receiver_type == kImmutableArrayCid ||
+           receiver_type == kGrowableObjectArrayCid);
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     ASSERT(value != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
     inputs_[2] = value;
   }
 
   DECLARE_INSTRUCTION(StoreIndexed)
   virtual RawAbstractType* CompileType() const;
@@ skipping 219 matching lines @@
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureInstr);
 };
 
 
 class LoadVMFieldInstr : public TemplateDefinition<1> {
  public:
   LoadVMFieldInstr(Value* value,
                    intptr_t offset_in_bytes,
-                   const AbstractType& type)
+                   const AbstractType& type,
+                   bool immutable = false)

[srdjan, 2012/09/12 07:06:40]

I think setting immutable_ via a setter (similar to set_result_cid) is better:
no default arguments needed and better documentation at call site than passing
true/false. Otherwise, please make immutable_const.

[Florian Schneider, 2012/09/12 08:27:29]

Done. Making it const for now.

       : offset_in_bytes_(offset_in_bytes),
         type_(type),
-        result_cid_(kDynamicCid) {
+        result_cid_(kDynamicCid),
+        immutable_(immutable) {
     ASSERT(value != NULL);
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(LoadVMField)
   virtual RawAbstractType* CompileType() const;
 
   Value* value() const { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
   virtual intptr_t ResultCid() const { return result_cid_; }
 
+  bool AttributesEqual(Definition* other) const;
+
+  virtual bool AffectedBySideEffect() const { return !immutable_; }
+
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
+  bool immutable_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadVMFieldInstr);
 };
 
 
 class StoreVMFieldInstr : public TemplateDefinition<2> {
  public:
   StoreVMFieldInstr(Value* dest,
                     intptr_t offset_in_bytes,
                     Value* value,
@@ skipping 232 matching lines @@
   }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AffectedBySideEffect() const { return false; }
 
   Value* left() const { return inputs_[0]; }
 
   Value* right() const { return inputs_[1]; }
 
   virtual Definition* Canonicalize();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
 
 class BoxDoubleInstr : public TemplateDefinition<1> {
  public:
   BoxDoubleInstr(Value* value, InstanceCallInstr* instance_call)
       : token_pos_((instance_call != NULL) ? instance_call->token_pos() : 0) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
   virtual intptr_t ResultCid() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   DECLARE_INSTRUCTION(BoxDouble)
@@ skipping 20 matching lines @@
     return value()->ResultCid() != kDoubleCid;
   }
 
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxDouble)
   virtual RawAbstractType* CompileType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
@@ skipping 12 matching lines @@
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AffectedBySideEffect() const { return false; }
 
   virtual bool AttributesEqual(Definition* other) const {
     return op_kind() == other->AsUnboxedDoubleBinaryOp()->op_kind();
   }
 
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
@@ skipping 239 matching lines @@
   }
 
   DECLARE_INSTRUCTION(CheckClass)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const;
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AffectedBySideEffect() const { return false; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
   virtual Definition* Canonicalize();
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
@@ skipping 13 matching lines @@
   }
 
   DECLARE_INSTRUCTION(CheckSmi)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const { return true; }
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AffectedBySideEffect() const { return false; }
 
   virtual Definition* Canonicalize();
 
   Value* value() const { return inputs_[0]; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
@@ skipping 12 matching lines @@
   }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return true; }
   virtual intptr_t ResultCid() const { return kIllegalCid; }
 
   virtual bool AttributesEqual(Definition* other) const;
 
-  virtual bool HasSideEffect() const { return false; }
+  virtual bool AffectedBySideEffect() const { return false; }
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
 
   intptr_t array_type() const { return array_type_; }
 
  private:
   intptr_t array_type_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundInstr);
@@ skipping 181 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_