Enable allocation sinking for closures.

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 3176 matching lines @@
       : num_temps_(num_temps) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(DropTemps)
 
   Value* value() const { return inputs_[0]; }
 
   intptr_t num_temps() const { return num_temps_; }
 
-  virtual CompileType ComputeType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
   virtual bool MayThrow() const {
     UNREACHABLE();
@@ skipping 463 matching lines @@
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
 };
 
 
 class AllocateObjectInstr : public TemplateDefinition<0> {
  public:
-  AllocateObjectInstr(ConstructorCallNode* node,
+  AllocateObjectInstr(intptr_t token_pos,
+                      const Class& cls,
                       ZoneGrowableArray<PushArgumentInstr*>* arguments)
-      : ast_node_(*node),
+      : token_pos_(token_pos),
+        cls_(cls),
         arguments_(arguments),
-        cid_(Class::Handle(node->constructor().Owner()).id()),
-        identity_(kUnknown) {
+        identity_(kUnknown),
+        closure_function_(Function::ZoneHandle()),
+        context_field_(Field::ZoneHandle()) {
     // Either no arguments or one type-argument and one instantiator.
     ASSERT(arguments->is_empty() || (arguments->length() == 2));
   }
 
   DECLARE_INSTRUCTION(AllocateObject)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
-  const Function& constructor() const { return ast_node_.constructor(); }
-  intptr_t token_pos() const { return ast_node_.token_pos(); }
+  const Class& cls() const { return cls_; }
+  intptr_t token_pos() const { return token_pos_; }
+
+  const Function& closure_function() const { return closure_function_; }
+  void set_closure_function(const Function& function) {
+    closure_function_ ^= function.raw();
+  }
+
+  const Field& context_field() const { return context_field_; }
+  void set_context_field(const Field& field) {
+    context_field_ ^= field.raw();
+  }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
   // If the result of the allocation is not stored into any field, passed
   // as an argument or used in a phi then it can't alias with any other
   // SSA value.
   enum Identity {
     kUnknown,
     kAliased,
     kNotAliased
   };
 
   Identity identity() const { return identity_; }
   void set_identity(Identity identity) { identity_ = identity; }
 
  private:
-  const ConstructorCallNode& ast_node_;
+  const intptr_t token_pos_;
+  const Class& cls_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
-  const intptr_t cid_;
   Identity identity_;
+  Function& closure_function_;
+  Field& context_field_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
 
 
 // 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:
@@ skipping 228 matching lines @@
  public:
   LoadFieldInstr(Value* instance,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  bool immutable = false)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(immutable),
         recognized_kind_(MethodRecognizer::kUnknown),
-        field_name_(NULL),
         field_(NULL) {
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     SetInputAt(0, instance);
   }
 
   Value* instance() 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; }
   intptr_t result_cid() const { return result_cid_; }
 
-  void set_field_name(const char* name) { field_name_ = name; }
-  const char* field_name() const { return field_name_; }
-
   const Field* field() const { return field_; }
   void set_field(const Field* field) { field_ = field; }
 
   void set_recognized_kind(MethodRecognizer::Kind kind) {
     recognized_kind_ = kind;
   }
 
   MethodRecognizer::Kind recognized_kind() const {
     return recognized_kind_;
   }
@@ skipping 23 matching lines @@
   virtual bool MayThrow() const { return false; }
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   const bool immutable_;
 
   MethodRecognizer::Kind recognized_kind_;
 
-  const char* field_name_;
   const Field* field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
 
 class StoreVMFieldInstr : public TemplateDefinition<2> {
  public:
   StoreVMFieldInstr(Value* dest,
                     intptr_t offset_in_bytes,
@@ skipping 2572 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_