Allocation sinking for contexts.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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 3865 matching lines @@
   const intptr_t token_pos_;
   const Class& cls_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   AliasIdentity identity_;
   Function& closure_function_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
 
 
+class AllocateUninitializedContextInstr
+    : public TemplateDefinition<0, NoThrow> {
+ public:
+  AllocateUninitializedContextInstr(intptr_t token_pos,
+                                    intptr_t num_context_variables)
+      : token_pos_(token_pos),
+        num_context_variables_(num_context_variables),
+        identity_(AliasIdentity::Unknown()) {}
+
+  DECLARE_INSTRUCTION(AllocateUninitializedContext)
+  virtual CompileType ComputeType() const;
+
+  virtual intptr_t token_pos() const { return token_pos_; }
+  intptr_t num_context_variables() const { return num_context_variables_; }
+
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
+
+  virtual bool CanDeoptimize() const { return false; }
+
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
+  virtual AliasIdentity Identity() const { return identity_; }
+  virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
+
+ private:
+  const intptr_t token_pos_;
+  const intptr_t num_context_variables_;
+  AliasIdentity identity_;
+
+  DISALLOW_COPY_AND_ASSIGN(AllocateUninitializedContextInstr);
+};
+
+
 // This instruction captures the state of the object which had its allocation
 // removed during the AllocationSinking pass.
 // It does not produce any real code only deoptimization information.
 class MaterializeObjectInstr : public Definition {
  public:
   MaterializeObjectInstr(AllocateObjectInstr* allocation,
-                         const Class& cls,
                          const ZoneGrowableArray<const Object*>& slots,
                          ZoneGrowableArray<Value*>* values)
       : allocation_(allocation),
-        cls_(cls),
+        cls_(allocation->cls()),
+        num_variables_(-1),
         slots_(slots),
         values_(values),
         locations_(NULL),
         visited_for_liveness_(false),
         registers_remapped_(false) {
     ASSERT(slots_.length() == values_->length());
     for (intptr_t i = 0; i < InputCount(); i++) {
       InputAt(i)->set_instruction(this);
       InputAt(i)->set_use_index(i);
     }
   }
 
-  AllocateObjectInstr* allocation() const { return allocation_; }
+  MaterializeObjectInstr(AllocateUninitializedContextInstr* allocation,
+                         const ZoneGrowableArray<const Object*>& slots,
+                         ZoneGrowableArray<Value*>* values)
+      : allocation_(allocation),
+        cls_(Class::ZoneHandle(Object::context_class())),
+        num_variables_(allocation->num_context_variables()),
+        slots_(slots),
+        values_(values),
+        locations_(NULL),
+        visited_for_liveness_(false),
+        registers_remapped_(false) {
+    ASSERT(slots_.length() == values_->length());
+    for (intptr_t i = 0; i < InputCount(); i++) {
+      InputAt(i)->set_instruction(this);
+      InputAt(i)->set_use_index(i);
+    }
+  }
+
+  Definition* allocation() const { return allocation_; }
   const Class& cls() const { return cls_; }
+
+  intptr_t num_variables() const {
+    return num_variables_;
+  }
+
   intptr_t FieldOffsetAt(intptr_t i) const {
     return slots_[i]->IsField()
         ? Field::Cast(*slots_[i]).Offset()
         : Smi::Cast(*slots_[i]).Value();
   }
+
   const Location& LocationAt(intptr_t i) {
     return locations_[i];
   }
 
   DECLARE_INSTRUCTION(MaterializeObject)
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual intptr_t InputCount() const {
     return values_->length();
   }
@@ skipping 26 matching lines @@
   bool was_visited_for_liveness() const { return visited_for_liveness_; }
   void mark_visited_for_liveness() {
     visited_for_liveness_ = true;
   }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*values_)[i] = value;
   }
 
-  AllocateObjectInstr* allocation_;
+  Definition* allocation_;
   const Class& cls_;
+  intptr_t num_variables_;
   const ZoneGrowableArray<const Object*>& slots_;
   ZoneGrowableArray<Value*>* values_;
   Location* locations_;
 
   bool visited_for_liveness_;
   bool registers_remapped_;
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
@@ skipping 269 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
 class AllocateContextInstr : public TemplateDefinition<0, NoThrow> {
  public:
   AllocateContextInstr(intptr_t token_pos,
                        intptr_t num_context_variables)
       : token_pos_(token_pos),
-        num_context_variables_(num_context_variables) {}
+        num_context_variables_(num_context_variables) { }
 
   DECLARE_INSTRUCTION(AllocateContext)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 26 matching lines @@
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldInstr);
 };
 
 
-class AllocateUninitializedContextInstr
-    : public TemplateDefinition<0, NoThrow> {
- public:
-  AllocateUninitializedContextInstr(intptr_t token_pos,
-                                    intptr_t num_context_variables)
-      : token_pos_(token_pos),
-        num_context_variables_(num_context_variables) {}
-
-  DECLARE_INSTRUCTION(AllocateUninitializedContext)
-  virtual CompileType ComputeType() const;
-
-  virtual intptr_t token_pos() const { return token_pos_; }
-  intptr_t num_context_variables() const { return num_context_variables_; }
-
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
-  virtual bool CanDeoptimize() const { return false; }
-
-  virtual EffectSet Effects() const { return EffectSet::None(); }
-
- private:
-  const intptr_t token_pos_;
-  const intptr_t num_context_variables_;
-
-  DISALLOW_COPY_AND_ASSIGN(AllocateUninitializedContextInstr);
-};
-
-
 class CloneContextInstr : public TemplateDefinition<1, NoThrow> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
       : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     SetInputAt(0, context_value);
   }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
@@ skipping 3430 matching lines @@
       Isolate* isolate, bool opt) const {                                     \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_