Implement a variation of scalar replacement for non-escaping allocations.

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 568 matching lines @@
   M(Float32x4Zero)                                                             \
   M(Float32x4Splat)                                                            \
   M(Float32x4Comparison)                                                       \
   M(Float32x4MinMax)                                                           \
   M(Float32x4Scale)                                                            \
   M(Float32x4Sqrt)                                                             \
   M(Float32x4ZeroArg)                                                          \
   M(Float32x4Clamp)                                                            \
   M(Float32x4With)                                                             \
   M(Float32x4ToUint32x4)                                                       \
-
+  M(MaterializeObject)                                                         \
 
 #define FORWARD_DECLARATION(type) class type##Instr;
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   virtual Tag tag() const { return k##type; }                                  \
   virtual void Accept(FlowGraphVisitor* visitor);                              \
@@ skipping 2895 matching lines @@
  private:
   const ConstructorCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const intptr_t cid_;
   Identity identity_;
 
   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:
+  MaterializeObjectInstr(const Class& cls,
+                         const ZoneGrowableArray<const Field*>& fields,
+                         ZoneGrowableArray<Value*>* values)
+      : cls_(cls), fields_(fields), values_(values), locations_(NULL) {
+    ASSERT(fields_.length() == values_->length());
+    for (intptr_t i = 0; i < InputCount(); i++) {
+      InputAt(i)->set_instruction(this);
+      InputAt(i)->set_use_index(i);
+    }
+  }
+
+  const Class& cls() const { return cls_; }
+  const Field& FieldAt(intptr_t i) const {
+    return *fields_[i];
+  }
+  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();
+  }
+
+  virtual Value* InputAt(intptr_t i) const {
+    return (*values_)[i];
+  }
+
+  virtual bool CanDeoptimize() const { return false; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
+  LocationSummary* locs() {
+    UNREACHABLE();
+    return NULL;
+  }
+
+  Location* locations() { return locations_; }
+  void set_locations(Location* locations) { locations_ = locations; }
+
+ private:
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    (*values_)[i] = value;
+  }
+
+  const Class& cls_;
+  const ZoneGrowableArray<const Field*>& fields_;
+  ZoneGrowableArray<Value*>* values_;
+  Location* locations_;
+
+  DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
+};
+
+
 class AllocateObjectWithBoundsCheckInstr : public TemplateDefinition<2> {
  public:
   AllocateObjectWithBoundsCheckInstr(ConstructorCallNode* node,
                                      Value* type_arguments,
                                      Value* instantiator)
       : ast_node_(*node) {
     SetInputAt(0, type_arguments);
     SetInputAt(1, instantiator);
   }
 
@@ skipping 2266 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_