Version 1.1.0-dev.5.7

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 464 matching lines @@
   void set_instruction(Instruction* instruction) { instruction_ = instruction; }
 
   intptr_t use_index() const { return use_index_; }
   void set_use_index(intptr_t index) { use_index_ = index; }
 
   static void AddToList(Value* value, Value** list);
   void RemoveFromUseList();
 
   // Change the definition after use lists have been computed.
   inline void BindTo(Definition* definition);
+  inline void BindToEnvironment(Definition* definition);
 
   Value* Copy() { return new Value(definition_); }
 
   // This function must only be used when the new Value is dominated by
   // the original Value.
   Value* CopyWithType() {
     Value* copy = new Value(definition_);
     copy->reaching_type_ = reaching_type_;
     return copy;
   }
@@ skipping 1292 matching lines @@
 
 
 // Change a value's definition after use lists have been computed.
 inline void Value::BindTo(Definition* def) {
   RemoveFromUseList();
   set_definition(def);
   def->AddInputUse(this);
 }
 
 
+inline void Value::BindToEnvironment(Definition* def) {
+  RemoveFromUseList();
+  set_definition(def);
+  def->AddEnvUse(this);
+}
+
+
 class PhiInstr : public Definition {
  public:
   PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
     : block_(block),
       inputs_(num_inputs),
       is_alive_(false),
       representation_(kTagged),
       reaching_defs_(NULL) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
@@ skipping 1605 matching lines @@
 
  private:
   const NativeBodyNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
 
 
 class DebugStepCheckInstr : public TemplateInstruction<0> {
  public:
-  explicit DebugStepCheckInstr(intptr_t token_pos)
-      : token_pos_(token_pos) {
+  DebugStepCheckInstr(intptr_t token_pos,
+                      PcDescriptors::Kind stub_kind)
+      : token_pos_(token_pos),
+        stub_kind_(stub_kind) {
   }
 
   DECLARE_INSTRUCTION(DebugStepCheck)
 
   intptr_t token_pos() const { return token_pos_; }
   virtual bool MayThrow() const { return false; }
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual intptr_t ArgumentCount() const { return 0; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const intptr_t token_pos_;
+  const PcDescriptors::Kind stub_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugStepCheckInstr);
 };
 
 
 enum StoreBarrierType {
   kNoStoreBarrier,
   kEmitStoreBarrier
 };
 
@@ skipping 851 matching lines @@
 
 class StoreVMFieldInstr : public TemplateDefinition<2> {
  public:
   StoreVMFieldInstr(Value* dest,
                     intptr_t offset_in_bytes,
                     Value* value,
                     const AbstractType& type)
       : offset_in_bytes_(offset_in_bytes), type_(type) {
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     SetInputAt(kValuePos, value);
-    SetInputAt(kDestPos, dest);
+    SetInputAt(kObjectPos, dest);
   }
 
   enum {
     kValuePos = 0,
-    kDestPos = 1
+    kObjectPos = 1
   };
 
   DECLARE_INSTRUCTION(StoreVMField)
   virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[kValuePos]; }
-  Value* dest() const { return inputs_[kDestPos]; }
+  Value* dest() const { return inputs_[kObjectPos]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
 
   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; }
@@ skipping 2777 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_