Make CTX allocatable by the register allocator.

runtime/vm/flow_graph_optimizer.cc

 // 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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 5122 matching lines @@
   check->value()->BindTo(phi->InputAt(non_smi_input)->definition());
 
   phi->UpdateType(CompileType::FromCid(kSmiCid));
 }
 
 
 // Load instructions handled by load elimination.
 static bool IsLoadEliminationCandidate(Instruction* instr) {
   return instr->IsLoadField()
       || instr->IsLoadIndexed()
-      || instr->IsLoadStaticField()
-      || instr->IsCurrentContext();
+      || instr->IsLoadStaticField();
 }
 
 
 static bool IsLoopInvariantLoad(ZoneGrowableArray<BitVector*>* sets,
                                 intptr_t loop_header_index,
                                 Instruction* instr) {
   return IsLoadEliminationCandidate(instr) &&
       (sets != NULL) &&
       instr->HasPlaceId() &&
       ((*sets)[loop_header_index] != NULL) &&
@@ skipping 122 matching lines @@
 
     // VMField location. Represented as a pair of an instance (SSA definition)
     // being accessed and offset to the field.
     kVMField,
 
     // Indexed location with a non-constant index.
     kIndexed,
 
     // Indexed location with a constant index.
     kConstantIndexed,
-
-    // Current context.
-    kContext
   };
 
   Place(const Place& other)
       : ValueObject(),
         kind_(other.kind_),
         representation_(other.representation_),
         instance_(other.instance_),
         raw_selector_(other.raw_selector_),
         id_(other.id_) {
   }
@@ skipping 66 matching lines @@
       case Instruction::kStoreIndexed: {
         StoreIndexedInstr* store_indexed = instr->AsStoreIndexed();
         representation_ = store_indexed->
             RequiredInputRepresentation(StoreIndexedInstr::kValuePos);
         instance_ = store_indexed->array()->definition()->OriginalDefinition();
         SetIndex(store_indexed->index()->definition());
         *is_store = true;
         break;
       }
 
-      case Instruction::kCurrentContext:
-        kind_ = kContext;
-        ASSERT(instr->AsCurrentContext()->representation() == kTagged);
-        representation_ = kTagged;
-        *is_load = true;
-        break;
-
-      case Instruction::kStoreContext:
-        kind_ = kContext;
-        ASSERT(instr->AsStoreContext()->RequiredInputRepresentation(
-            StoreContextInstr::kValuePos) == kTagged);
-        representation_ = kTagged;
-        *is_store = true;
-        break;
-
       default:
         break;
     }
   }
 
   // Create object representing *[*] alias.
   static Place* CreateAnyInstanceAnyIndexAlias(Isolate* isolate,
                                                intptr_t id) {
     return Wrap(isolate, Place(kIndexed, NULL, 0), id);
   }
@@ skipping 19 matching lines @@
   }
 
   bool DependsOnInstance() const {
     switch (kind()) {
       case kField:
       case kVMField:
       case kIndexed:
       case kConstantIndexed:
         return true;
 
-      case kContext:
       case kNone:
         return false;
     }
 
     UNREACHABLE();
     return false;
   }
 
   // Given instance dependent alias X.f, X.@offs, X[C], X[*] return
   // wild-card dependent alias *.f, *.@offs, *[C] or *[*] respectively.
@@ skipping 79 matching lines @@
         return Isolate::Current()->current_zone()->PrintToString(
             "<%s[%s]>",
             DefinitionName(instance()),
             DefinitionName(index()));
 
       case kConstantIndexed:
         return Isolate::Current()->current_zone()->PrintToString(
             "<%s[%" Pd "]>",
             DefinitionName(instance()),
             index_constant());
-
-      case kContext:
-        return "<context>";
     }
     UNREACHABLE();
     return "<?>";
   }
 
   bool IsFinalField() const {
     return (kind() == kField) && field().is_final();
   }
 
   intptr_t Hashcode() const {
@@ skipping 406 matching lines @@
           }
         }
         break;
 
       case Place::kField:
       case Place::kVMField:
         if (CanBeAliased(alias->instance())) {
           // X.f or X.@offs alias with *.f and *.@offs respectively.
           CrossAlias(alias, alias->CopyWithoutInstance());
         }
-
-      case Place::kContext:
-        return;
+        break;
 
       case Place::kNone:
         UNREACHABLE();
     }
   }
 
   // Returns true if the given load is unaffected by external side-effects.
   // This essentially means that no stores to the same location can
   // occur in other functions.
   bool IsIndependentFromEffects(Place* place) {
@@ skipping 179 matching lines @@
   StoreInstanceFieldInstr* store_instance_field = instr->AsStoreInstanceField();
   if (store_instance_field != NULL) {
     return store_instance_field->value()->definition();
   }
 
   StoreStaticFieldInstr* store_static_field = instr->AsStoreStaticField();
   if (store_static_field != NULL) {
     return store_static_field->value()->definition();
   }
 
-  if (instr->IsStoreContext()) {
-    return instr->InputAt(0)->definition();
-  }
-
   UNREACHABLE();  // Should only be called for supported store instructions.
   return NULL;
 }
 
 
 static bool IsPhiDependentPlace(Place* place) {
   return ((place->kind() == Place::kField) ||
           (place->kind() == Place::kVMField)) &&
         (place->instance() != NULL) &&
         place->instance()->IsPhi();
@@ skipping 1043 matching lines @@
     }
   }
 
   bool CanEliminateStore(Instruction* instr) {
     switch (instr->tag()) {
       case Instruction::kStoreInstanceField:
         if (instr->AsStoreInstanceField()->is_initialization()) {
           // Can't eliminate stores that initialized unboxed fields.
           return false;
         }
-      case Instruction::kStoreContext:
       case Instruction::kStoreIndexed:
       case Instruction::kStoreStaticField:
         return true;
       default:
         UNREACHABLE();
         return false;
     }
   }
 
   virtual void ComputeInitialSets() {
@@ skipping 519 matching lines @@
         SetReachable(instr->false_successor());
       }
     }
   }
 }
 
 
 // --------------------------------------------------------------------------
 // Analysis of non-definition instructions.  They do not have values so they
 // cannot have constant values.
-void ConstantPropagator::VisitStoreContext(StoreContextInstr* instr) { }
-
-
 void ConstantPropagator::VisitCheckStackOverflow(
     CheckStackOverflowInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckClass(CheckClassInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckClassId(CheckClassIdInstr* instr) { }
 
 
@@ skipping 2341 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart