VM: Remove unnecessary field use_kind from IL instructions.

runtime/vm/flow_graph.cc

 // Copyright (c) 2012, 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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 86 matching lines @@
   // TODO(zerny): Set previous to the graph entry so it is accessible by
   // GetBlock. Remove this once there is a direct pointer to the block.
   defn->set_previous(graph_entry_);
   graph_entry_->initial_definitions()->Add(defn);
 }
 
 
 void FlowGraph::InsertBefore(Instruction* next,
                              Instruction* instr,
                              Environment* env,
-                             Definition::UseKind use_kind) {
+                             UseKind use_kind) {
   InsertAfter(next->previous(), instr, env, use_kind);
 }
 
 
 void FlowGraph::InsertAfter(Instruction* prev,
                             Instruction* instr,
                             Environment* env,
-                            Definition::UseKind use_kind) {
-  if (use_kind == Definition::kValue) {
+                            UseKind use_kind) {
+  if (use_kind == kValue) {
     ASSERT(instr->IsDefinition());
     AllocateSSAIndexes(instr->AsDefinition());
   }
   instr->InsertAfter(prev);
   ASSERT(instr->env() == NULL);
   if (env != NULL) env->DeepCopyTo(instr);
 }
 
 
 Instruction* FlowGraph::AppendTo(Instruction* prev,
                                  Instruction* instr,
                                  Environment* env,
-                                 Definition::UseKind use_kind) {
-  if (use_kind == Definition::kValue) {
+                                 UseKind use_kind) {
+  if (use_kind == kValue) {
     ASSERT(instr->IsDefinition());
     AllocateSSAIndexes(instr->AsDefinition());
   }
   ASSERT(instr->env() == NULL);
   if (env != NULL) env->DeepCopyTo(instr);
   return prev->AppendInstruction(instr);
 }
 
 
 void FlowGraph::DiscoverBlocks() {
@@ skipping 744 matching lines @@
           result = store->value()->definition();
 
           if (variable_liveness->IsStoreAlive(block_entry, store)) {
             (*env)[index] = result;
           } else {
             (*env)[index] = constant_dead();
           }
         } else if (load != NULL) {
           // The graph construction ensures we do not have an unused LoadLocal
           // computation.
-          ASSERT(definition->is_used());
+          ASSERT(definition->HasTemp());
           intptr_t index = load->local().BitIndexIn(num_non_copied_params_);
           result = (*env)[index];
 
           PhiInstr* phi = result->AsPhi();
           if ((phi != NULL) && !phi->is_alive()) {
             phi->mark_alive();
             live_phis->Add(phi);
           }
 
           if (variable_liveness->IsLastLoad(block_entry, load)) {
             (*env)[index] = constant_dead();
           }
         } else if (push != NULL) {
           result = push->value()->definition();
           env->Add(result);
           it.RemoveCurrentFromGraph();
           continue;
         } else if (drop != NULL) {
           // Drop temps from the environment.
           for (intptr_t j = 0; j < drop->num_temps(); j++) {
             env->RemoveLast();
           }
           if (drop->value() != NULL) {
             result = drop->value()->definition();
           }
-          ASSERT((drop->value() != NULL) || !drop->is_used());
+          ASSERT((drop->value() != NULL) || !drop->HasTemp());
         } else {
-          ASSERT(definition->is_used());
+          ASSERT(definition->HasTemp());
           result = GetConstant(constant->value());
         }
         // Update expression stack or remove from graph.
-        if (definition->is_used()) {
+        if (definition->HasTemp()) {
           ASSERT(result != NULL);
           env->Add(result);
           // We remove load/store/constant instructions when we find their
           // use in 2a.
         } else {
           it.RemoveCurrentFromGraph();
         }
       } else {
         // Not a load, store, or constant.
-        if (definition->is_used()) {
+        if (definition->HasTemp()) {
           // Assign fresh SSA temporary and update expression stack.
           AllocateSSAIndexes(definition);
           env->Add(definition);
         }
       }
     }
 
     // 2c. Handle pushed argument.
     PushArgumentInstr* push = current->AsPushArgument();
     if (push != NULL) {
@@ skipping 280 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart