Support allocation sinking for compound objects.

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 1745 matching lines @@
   const LocalVariable& stacktrace_var_;
   const bool needs_stacktrace_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchBlockEntryInstr);
 };
 
 
 // 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 AliasIdentity {
-  kIdentityUnknown,
-  kIdentityAliased,
-  kIdentityNotAliased
+class AliasIdentity {

[srdjan, 2014/07/17 23:08:15]

: public ValueObject ?

[Vyacheslav Egorov (Google), 2014/07/18 11:25:08]

Done.

+ public:
+  // It is unknown if value has aliases.
+  static AliasIdentity Unknown() { return AliasIdentity(kUnknown); }
+
+  // It is known that value can have aliases.
+  static AliasIdentity Aliased() { return AliasIdentity(kAliased); }
+
+  // It is known that value has no aliases.
+  static AliasIdentity NotAliased() { return AliasIdentity(kNotAliased); }
+
+  // It is known that value has no aliases and it was selected by
+  // allocation sinking pass as a candidate.
+  static AliasIdentity AllocationSinkingCandidate() {
+    return AliasIdentity(kAllocationSinkingCandidate);
+  }
+
+  bool IsUnknown() const { return value_ == kUnknown; }
+  bool IsAliased() const { return value_ == kAliased; }
+  bool IsNotAliased() const { return (value_ & kNotAliased) != 0; }
+  bool IsAllocationSinkingCandidate() const {
+    return value_ == kAllocationSinkingCandidate;
+  }
+
+ private:
+  explicit AliasIdentity(intptr_t value) : value_(value) { }
+
+  enum {
+    kUnknown = 0,
+    kNotAliased = 1,
+    kAliased = 2,
+    kAllocationSinkingCandidate = 3,
+  };
+
+  COMPILE_ASSERT((kUnknown & kNotAliased) == 0);
+  COMPILE_ASSERT((kAliased & kNotAliased) == 0);
+  COMPILE_ASSERT((kAllocationSinkingCandidate & kNotAliased) != 0);
+
+  intptr_t value_;

[srdjan, 2014/07/17 23:08:15]

const

[Vyacheslav Egorov (Google), 2014/07/18 11:25:08]

It can't be const because we have fields of this type that we change once it is
computed (see SetIdentity).

 };
 
 
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
   Definition();
 
   virtual Definition* AsDefinition() { return this; }
 
@@ skipping 140 matching lines @@
   }
 
   void SetReplacement(Definition* other) {
     ASSERT(ssa_temp_index_ >= 0);
     ASSERT(WasEliminated());
     ssa_temp_index_ = kReplacementMarker;
     temp_index_ = reinterpret_cast<intptr_t>(other);
   }
 
   virtual AliasIdentity Identity() const {
-    // Only implemented for allocation instructions.
-    UNREACHABLE();
-    return kIdentityUnknown;
+    return AliasIdentity::Unknown();
   }
 
   virtual void SetIdentity(AliasIdentity identity) {
     UNREACHABLE();
   }
 
   Definition* OriginalDefinition();
 
  protected:
   friend class RangeAnalysis;
@@ skipping 1679 matching lines @@
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   const ZoneGrowableArray<const ICData*>& ic_data_array)
       : ic_data_(GetICData(ic_data_array)),
         token_pos_(token_pos),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         is_native_list_factory_(false),
-        identity_(kIdentityUnknown) {
+        identity_(AliasIdentity::Unknown()) {
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle() ||  argument_names.InVMHeap());
   }
 
   // ICData for static calls carries call count.
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
@@ skipping 824 matching lines @@
 
 
 class AllocateObjectInstr : public TemplateDefinition<0> {
  public:
   AllocateObjectInstr(intptr_t token_pos,
                       const Class& cls,
                       ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : token_pos_(token_pos),
         cls_(cls),
         arguments_(arguments),
-        identity_(kIdentityUnknown),
+        identity_(AliasIdentity::Unknown()),
         closure_function_(Function::ZoneHandle()) {
     // Either no arguments or one type-argument and one instantiator.
     ASSERT(arguments->is_empty() || (arguments->length() == 1));
   }
 
   DECLARE_INSTRUCTION(AllocateObject)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
@@ skipping 28 matching lines @@
 
   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,
+  MaterializeObjectInstr(AllocateObjectInstr* allocation,
+                         const Class& cls,
                          const ZoneGrowableArray<const Object*>& slots,
                          ZoneGrowableArray<Value*>* values)
-      : cls_(cls), slots_(slots), values_(values), locations_(NULL) {
+      : allocation_(allocation),
+        cls_(cls),
+        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_; }
   const Class& cls() const { return cls_; }
   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];
   }
 
@@ skipping 22 matching lines @@
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   Location* locations() { return locations_; }
   void set_locations(Location* locations) { locations_ = locations; }
 
   virtual bool MayThrow() const { return false; }
 
   void RemapRegisters(intptr_t* fpu_reg_slots,
                       intptr_t* cpu_reg_slots);
 
+  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_;
   const Class& cls_;
   const ZoneGrowableArray<const Object*>& slots_;
   ZoneGrowableArray<Value*>* values_;
   Location* locations_;
 
+  bool visited_for_liveness_;
+  bool registers_remapped_;
+
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<2> {
  public:
   CreateArrayInstr(intptr_t token_pos,
                    Value* element_type,
                    Value* num_elements)
-      : token_pos_(token_pos), identity_(kIdentityUnknown)  {
+      : token_pos_(token_pos), identity_(AliasIdentity::Unknown())  {
     SetInputAt(kElementTypePos, element_type);
     SetInputAt(kLengthPos, num_elements);
   }
 
   enum {
     kElementTypePos = 0,
     kLengthPos = 1
   };
 
   DECLARE_INSTRUCTION(CreateArray)
@@ skipping 82 matching lines @@
   }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
 };
 
 
-
-
 class LoadFieldInstr : public TemplateDefinition<1> {
  public:
   LoadFieldInstr(Value* instance,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  intptr_t token_pos)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(false),
@@ skipping 3855 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_