Add alias disambiguation for VM fields.

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 3999 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_(kUnknown),
-        closure_function_(Function::ZoneHandle()),
-        context_field_(Field::ZoneHandle()) {
+        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 {
     return (*arguments_)[index];
   }
 
   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 intptr_t token_pos_;
   const Class& cls_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   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 {

[srdjan, 2014/03/07 17:38:37]

Please rename 'fields' to fields_or_offsets'. Such a name can be used instead of
additional argument documentation. Also on other places as well.

[Florian Schneider, 2014/03/10 09:46:48]

Done. Renamed to 'slots' since I prefer a concise name.

  public:
   MaterializeObjectInstr(const Class& cls,
-                         const ZoneGrowableArray<const Field*>& fields,
+                         const ZoneGrowableArray<const Object*>& 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_; }
   intptr_t FieldOffsetAt(intptr_t i) const {
-    return fields_[i]->Offset();
+    return fields_[i]->IsField()
+        ? Field::Cast(*fields_[i]).Offset()
+        : Smi::Cast(*fields_[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 20 matching lines @@
   void set_locations(Location* locations) { locations_ = locations; }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*values_)[i] = value;
   }
 
   const Class& cls_;
-  const ZoneGrowableArray<const Field*>& fields_;
+  const ZoneGrowableArray<const Object*>& fields_;
   ZoneGrowableArray<Value*>* values_;
   Location* locations_;
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<2> {
  public:
   CreateArrayInstr(intptr_t token_pos,
@@ skipping 3054 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_