VM: Remove unnecessary field use_kind from IL instructions.

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 303 matching lines @@
   const intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(cid);
   ConstantInstr* index_instr =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(ix)));
   LoadIndexedInstr* load = new LoadIndexedInstr(new Value(instr),
                                                 new Value(index_instr),
                                                 index_scale,
                                                 cid,
                                                 Isolate::kNoDeoptId,
                                                 instr->token_pos());
   instr->ReplaceUsesWith(load);
-  flow_graph()->InsertAfter(instr, load, NULL, Definition::kValue);
+  flow_graph()->InsertAfter(instr, load, NULL, FlowGraph::kValue);
 }
 
 
 void FlowGraphOptimizer::AppendExtractNthOutputForMerged(Definition* instr,
                                                          intptr_t index,
                                                          Representation rep,
                                                          intptr_t cid) {
   ExtractNthOutputInstr* extract = new ExtractNthOutputInstr(new Value(instr),
                                                              index,
                                                              rep,
                                                              cid);
   instr->ReplaceUsesWith(extract);
-  flow_graph()->InsertAfter(instr, extract, NULL, Definition::kValue);
+  flow_graph()->InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 
 // Dart:
 //  var x = d % 10;
 //  var y = d ~/ 10;
 //  var z = x + y;
 //
 // IL:
 //  v4 <- %(v2, v3)
@@ skipping 261 matching lines @@
 
   } else if ((from == kUnboxedMint) && (to == kTagged)) {
     converted = new BoxIntegerInstr(use->CopyWithType());
 
   } else if (from == kUnboxedMint && to == kUnboxedDouble) {
     ASSERT(CanUnboxDouble());
     // Convert by boxing/unboxing.
     // TODO(fschneider): Implement direct unboxed mint-to-double conversion.
     BoxIntegerInstr* boxed = new BoxIntegerInstr(use->CopyWithType());
     use->BindTo(boxed);
-    InsertBefore(insert_before, boxed, NULL, Definition::kValue);
+    InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
 
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     converted = new UnboxDoubleInstr(new Value(boxed), deopt_id);
 
   } else if ((from == kUnboxedDouble) && (to == kTagged)) {
     ASSERT(CanUnboxDouble());
     converted = new BoxDoubleInstr(use->CopyWithType());
 
   } else if ((from == kTagged) && (to == kUnboxedDouble)) {
@@ skipping 51 matching lines @@
     } else if (from == kUnboxedFloat32x4) {
       boxed = new BoxFloat32x4Instr(use->CopyWithType());
     } else if (from == kUnboxedMint) {
       boxed = new BoxIntegerInstr(use->CopyWithType());
     } else if (from == kUnboxedFloat64x2) {
       boxed = new BoxFloat64x2Instr(use->CopyWithType());
     } else {
       UNIMPLEMENTED();
     }
     use->BindTo(boxed);
-    InsertBefore(insert_before, boxed, NULL, Definition::kValue);
+    InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
     Value* to_value = new Value(boxed);
     if (to == kUnboxedDouble) {
       converted = new UnboxDoubleInstr(to_value, deopt_id);
     } else if (to == kUnboxedInt32x4) {
       converted = new UnboxInt32x4Instr(to_value, deopt_id);
     } else if (to == kUnboxedFloat32x4) {
       converted = new UnboxFloat32x4Instr(to_value, deopt_id);
     } else if (to == kUnboxedMint) {
       converted = new UnboxIntegerInstr(to_value, deopt_id);
     } else if (to == kUnboxedFloat64x2) {
       converted = new UnboxFloat64x2Instr(to_value, deopt_id);
     } else {
       UNIMPLEMENTED();
     }
   }
   ASSERT(converted != NULL);
   InsertBefore(insert_before, converted, use->instruction()->env(),
-               Definition::kValue);
+               FlowGraph::kValue);
   if (is_environment_use) {
     use->BindToEnvironment(converted);
   } else {
     use->BindTo(converted);
   }
 }
 
 
 void FlowGraphOptimizer::ConvertUse(Value* use, Representation from_rep) {
   const Representation to_rep =
@@ skipping 257 matching lines @@
 void FlowGraphOptimizer::AddCheckSmi(Definition* to_check,
                                      intptr_t deopt_id,
                                      Environment* deopt_environment,
                                      Instruction* insert_before) {
   if (to_check->Type()->ToCid() != kSmiCid) {
     InsertBefore(insert_before,
                  new CheckSmiInstr(new Value(to_check),
                                    deopt_id,
                                    insert_before->token_pos()),
                  deopt_environment,
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
   }
 }
 
 
 Instruction* FlowGraphOptimizer::GetCheckClass(Definition* to_check,
                                                const ICData& unary_checks,
                                                intptr_t deopt_id,
                                                intptr_t token_pos) {
   if ((unary_checks.NumberOfChecks() == 1) &&
       (unary_checks.GetReceiverClassIdAt(0) == kSmiCid)) {
     return new CheckSmiInstr(new Value(to_check),
                              deopt_id,
                              token_pos);
   }
   return new CheckClassInstr(
       new Value(to_check), deopt_id, unary_checks, token_pos);
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(Definition* to_check,
                                        const ICData& unary_checks,
                                        intptr_t deopt_id,
                                        Environment* deopt_environment,
                                        Instruction* insert_before) {
   // Type propagation has not run yet, we cannot eliminate the check.
   Instruction* check = GetCheckClass(
       to_check, unary_checks, deopt_id, insert_before->token_pos());
-  InsertBefore(insert_before, check, deopt_environment, Definition::kEffect);
+  InsertBefore(insert_before, check, deopt_environment, FlowGraph::kEffect);
 }
 
 
 void FlowGraphOptimizer::AddReceiverCheck(InstanceCallInstr* call) {
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks()),
                 call->deopt_id(),
                 call->env(),
                 call);
 }
@@ skipping 174 matching lines @@
         intptr_t type_arguments_field_offset =
             instantiator_class.type_arguments_field_offset();
         LoadFieldInstr* load_type_args =
             new LoadFieldInstr(new Value(array),
                                type_arguments_field_offset,
                                Type::ZoneHandle(),  // No type.
                                call->token_pos());
         cursor = flow_graph()->AppendTo(cursor,
                                         load_type_args,
                                         NULL,
-                                        Definition::kValue);
+                                        FlowGraph::kValue);
 
         instantiator = array;
         type_args = load_type_args;
         break;
       }
       case kTypedDataInt8ArrayCid:
       case kTypedDataUint8ArrayCid:
       case kTypedDataUint8ClampedArrayCid:
       case kExternalTypedDataUint8ArrayCid:
       case kExternalTypedDataUint8ClampedArrayCid:
@@ skipping 37 matching lines @@
                                   new Value(type_args),
                                   value_type,
                                   Symbols::Value());
     // Newly inserted instructions that can deoptimize or throw an exception
     // must have a deoptimization id that is valid for lookup in the unoptimized
     // code.
     assert_value->deopt_id_ = call->deopt_id();
     cursor = flow_graph()->AppendTo(cursor,
                                     assert_value,
                                     call->env(),
-                                    Definition::kValue);
+                                    FlowGraph::kValue);
   }
 
   array_cid = PrepareInlineIndexedOp(call,
                                      array_cid,
                                      &array,
                                      index,
                                      &cursor);
 
   // Check if store barrier is needed. Byte arrays don't need a store barrier.
   StoreBarrierType needs_store_barrier =
       (RawObject::IsTypedDataClassId(array_cid) ||
        RawObject::IsTypedDataViewClassId(array_cid) ||
        RawObject::IsExternalTypedDataClassId(array_cid)) ? kNoStoreBarrier
                                                          : kEmitStoreBarrier;
   if (!value_check.IsNull()) {
     // No store barrier needed because checked value is a smi, an unboxed mint,
     // an unboxed double, an unboxed Float32x4, or unboxed Int32x4.
     needs_store_barrier = kNoStoreBarrier;
     Instruction* check = GetCheckClass(
         stored_value, value_check, call->deopt_id(), call->token_pos());
     cursor = flow_graph()->AppendTo(cursor,
                                     check,
                                     call->env(),
-                                    Definition::kEffect);
+                                    FlowGraph::kEffect);
   }
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     stored_value =
         new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
-                                    Definition::kValue);
+                                    FlowGraph::kValue);
   }
 
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
   *last = new StoreIndexedInstr(new Value(array),
                                 new Value(index),
                                 new Value(stored_value),
                                 needs_store_barrier,
                                 index_scale,
                                 array_cid,
                                 call->deopt_id(),
                                 call->token_pos());
   flow_graph()->AppendTo(cursor,
                          *last,
                          call->env(),
-                         Definition::kEffect);
+                         FlowGraph::kEffect);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target,
                                                    Instruction* call,
                                                    Definition* receiver,
                                                    intptr_t token_pos,
                                                    const ICData& ic_data,
@@ skipping 233 matching lines @@
                                                     intptr_t array_cid,
                                                     Definition** array,
                                                     Definition* index,
                                                     Instruction** cursor) {
   // Insert index smi check.
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckSmiInstr(new Value(index),
                                                      call->deopt_id(),
                                                      call->token_pos()),
                                    call->env(),
-                                   Definition::kEffect);
+                                   FlowGraph::kEffect);
 
   // Insert array length load and bounds check.
   LoadFieldInstr* length =
       new LoadFieldInstr(new Value(*array),
                          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
                          Type::ZoneHandle(Type::SmiType()),
                          call->token_pos());
   length->set_is_immutable(
       CheckArrayBoundInstr::IsFixedLengthArrayType(array_cid));
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(array_cid));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    length,
                                    NULL,
-                                   Definition::kValue);
+                                   FlowGraph::kValue);
 
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckArrayBoundInstr(
                                        new Value(length),
                                        new Value(index),
                                        call->deopt_id()),
                                    call->env(),
-                                   Definition::kEffect);
+                                   FlowGraph::kEffect);
 
   if (array_cid == kGrowableObjectArrayCid) {
     // Insert data elements load.
     LoadFieldInstr* elements =
         new LoadFieldInstr(new Value(*array),
                            GrowableObjectArray::data_offset(),
                            Type::ZoneHandle(Type::DynamicType()),
                            call->token_pos());
     elements->set_result_cid(kArrayCid);
     *cursor = flow_graph()->AppendTo(*cursor,
                                      elements,
                                      NULL,
-                                     Definition::kValue);
+                                     FlowGraph::kValue);
     // Load from the data from backing store which is a fixed-length array.
     *array = elements;
     array_cid = kArrayCid;
   } else if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements =
         new LoadUntaggedInstr(new Value(*array),
                               ExternalTypedData::data_offset());
     *cursor = flow_graph()->AppendTo(*cursor,
                                      elements,
                                      NULL,
-                                     Definition::kValue);
+                                     FlowGraph::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 bool FlowGraphOptimizer::InlineGetIndexed(MethodRecognizer::Kind kind,
                                           Instruction* call,
                                           Definition* receiver,
                                           const ICData& ic_data,
                                           TargetEntryInstr** entry,
@@ skipping 28 matching lines @@
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                index_scale,
                                array_cid,
                                deopt_id,
                                call->token_pos());
   cursor = flow_graph()->AppendTo(
       cursor,
       *last,
       deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
-      Definition::kValue);
+      FlowGraph::kValue);
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
     flow_graph()->AppendTo(cursor,
                            *last,
                            deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
-                           Definition::kValue);
+                           FlowGraph::kValue);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
   if (ic_data.NumberOfChecks() != 1) return false;
@@ skipping 103 matching lines @@
           ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecksForArgNr(1));
       AddCheckClass(right,
                     unary_checks_1,
                     call->deopt_id(),
                     call->env(),
                     call);
       // String-to-char-code instructions returns -1 (illegal charcode) if
       // string is not of length one.
       StringToCharCodeInstr* char_code_right =
           new StringToCharCodeInstr(new Value(right), kOneByteStringCid);
-      InsertBefore(call, char_code_right, call->env(), Definition::kValue);
+      InsertBefore(call, char_code_right, call->env(), FlowGraph::kValue);
       right_val = new Value(char_code_right);
     }
 
     // Comparing char-codes instead of strings.
     EqualityCompareInstr* comp =
         new EqualityCompareInstr(call->token_pos(),
                                  op_kind,
                                  left_val,
                                  right_val,
                                  kSmiCid,
@@ skipping 34 matching lines @@
       return true;
     } else {
       return false;
     }
   } else if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
                  new CheckSmiInstr(new Value(left),
                                    call->deopt_id(),
                                    call->token_pos()),
                  call->env(),
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
     InsertBefore(call,
                  new CheckSmiInstr(new Value(right),
                                    call->deopt_id(),
                                    call->token_pos()),
                  call->env(),
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
     cid = kSmiCid;
   } else if (HasTwoMintOrSmi(ic_data) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     cid = kMintCid;
   } else if (HasTwoDoubleOrSmi(ic_data) && CanUnboxDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
     } else {
       if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
         // We cannot use double comparison on two smis. Need polymorphic
         // call.
         return false;
       } else {
         InsertBefore(call,
                      new CheckEitherNonSmiInstr(new Value(left),
                                                 new Value(right),
                                                 call->deopt_id()),
                      call->env(),
-                     Definition::kEffect);
+                     FlowGraph::kEffect);
         cid = kDoubleCid;
       }
     }
   } else {
     // Check if ICDData contains checks with Smi/Null combinations. In that case
     // we can still emit the optimized Smi equality operation but need to add
     // checks for null or Smi.
     GrowableArray<intptr_t> smi_or_null(2);
     smi_or_null.Add(kSmiCid);
     smi_or_null.Add(kNullCid);
@@ skipping 55 matching lines @@
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
                  new CheckSmiInstr(new Value(left),
                                    call->deopt_id(),
                                    call->token_pos()),
                  call->env(),
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
     InsertBefore(call,
                  new CheckSmiInstr(new Value(right),
                                    call->deopt_id(),
                                    call->token_pos()),
                  call->env(),
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
     cid = kSmiCid;
   } else if (HasTwoMintOrSmi(ic_data) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     cid = kMintCid;
   } else if (HasTwoDoubleOrSmi(ic_data) && CanUnboxDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
     } else {
       if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
         // We cannot use double comparison on two smis. Need polymorphic
         // call.
         return false;
       } else {
         InsertBefore(call,
                      new CheckEitherNonSmiInstr(new Value(left),
                                                 new Value(right),
                                                 call->deopt_id()),
                      call->env(),
-                     Definition::kEffect);
+                     FlowGraph::kEffect);
         cid = kDoubleCid;
       }
     }
   } else {
     return false;
   }
   ASSERT(cid != kIllegalCid);
   RelationalOpInstr* comp = new RelationalOpInstr(call->token_pos(),
                                                   op_kind,
                                                   new Value(left),
@@ skipping 129 matching lines @@
     }
     // Check that either left or right are not a smi.  Result of a
     // binary operation with two smis is a smi not a double, except '/' which
     // returns a double for two smis.
     if (op_kind != Token::kDIV) {
       InsertBefore(call,
                    new CheckEitherNonSmiInstr(new Value(left),
                                               new Value(right),
                                               call->deopt_id()),
                    call->env(),
-                   Definition::kEffect);
+                   FlowGraph::kEffect);
     }
 
     BinaryDoubleOpInstr* double_bin_op =
         new BinaryDoubleOpInstr(op_kind, new Value(left), new Value(right),
                                 call->deopt_id(), call->token_pos());
     ReplaceCall(call, double_bin_op);
   } else if (operands_type == kMintCid) {
     if (!FlowGraphCompiler::SupportsUnboxedMints()) return false;
     if ((op_kind == Token::kSHR) || (op_kind == Token::kSHL)) {
       ShiftMintOpInstr* shift_op =
@@ skipping 17 matching lines @@
     if (right->IsConstant()) {
       const Object& obj = right->AsConstant()->value();
       if (obj.IsSmi() && Utils::IsPowerOfTwo(Smi::Cast(obj).Value())) {
         // Insert smi check and attach a copy of the original environment
         // because the smi operation can still deoptimize.
         InsertBefore(call,
                      new CheckSmiInstr(new Value(left),
                                        call->deopt_id(),
                                        call->token_pos()),
                      call->env(),
-                     Definition::kEffect);
+                     FlowGraph::kEffect);
         ConstantInstr* constant =
             flow_graph()->GetConstant(Smi::Handle(
                 Smi::New(Smi::Cast(obj).Value() - 1)));
         BinarySmiOpInstr* bin_op =
             new BinarySmiOpInstr(Token::kBIT_AND,
                                  new Value(left),
                                  new Value(constant),
                                  call->deopt_id(),
                                  call->token_pos());
         ReplaceCall(call, bin_op);
@@ skipping 34 matching lines @@
                                                Token::Kind op_kind) {
   ASSERT(call->ArgumentCount() == 1);
   Definition* input = call->ArgumentAt(0);
   Definition* unary_op = NULL;
   if (HasOnlyOneSmi(*call->ic_data())) {
     InsertBefore(call,
                  new CheckSmiInstr(new Value(input),
                                    call->deopt_id(),
                                    call->token_pos()),
                  call->env(),
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
     unary_op = new UnarySmiOpInstr(op_kind, new Value(input), call->deopt_id());
   } else if ((op_kind == Token::kBIT_NOT) &&
              HasOnlySmiOrMint(*call->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     unary_op = new UnaryMintOpInstr(
         op_kind, new Value(input), call->deopt_id());
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE) &&
              CanUnboxDouble()) {
     AddReceiverCheck(call);
@@ skipping 466 matching lines @@
     intptr_t cid,
     Definition* str,
     Definition* index,
     Instruction* cursor) {
 
   cursor = flow_graph()->AppendTo(cursor,
                                   new CheckSmiInstr(new Value(index),
                                                     call->deopt_id(),
                                                     call->token_pos()),
                                   call->env(),
-                                  Definition::kEffect);
+                                  FlowGraph::kEffect);
 
   // Load the length of the string.
   LoadFieldInstr* length = BuildLoadStringLength(str);
-  cursor = flow_graph()->AppendTo(cursor, length, NULL, Definition::kValue);
+  cursor = flow_graph()->AppendTo(cursor, length, NULL, FlowGraph::kValue);
   // Bounds check.
   cursor = flow_graph()->AppendTo(cursor,
                                    new CheckArrayBoundInstr(new Value(length),
                                                             new Value(index),
                                                             call->deopt_id()),
                                    call->env(),
-                                   Definition::kEffect);
+                                   FlowGraph::kEffect);
 
   LoadIndexedInstr* load_indexed = new LoadIndexedInstr(
       new Value(str),
       new Value(index),
       FlowGraphCompiler::ElementSizeFor(cid),
       cid,
       Isolate::kNoDeoptId,
       call->token_pos());
 
   cursor = flow_graph()->AppendTo(cursor,
                                   load_indexed,
                                   NULL,
-                                  Definition::kValue);
+                                  FlowGraph::kValue);
   ASSERT(cursor == load_indexed);
   return load_indexed;
 }
 
 
 bool FlowGraphOptimizer::InlineStringCodeUnitAt(
     Instruction* call,
     intptr_t cid,
     TargetEntryInstr** entry,
     Definition** last) {
@@ skipping 29 matching lines @@
 
   *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
                                 call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(call);
 
   *last = PrepareInlineStringIndexOp(call, cid, str, index, *entry);
 
   StringFromCharCodeInstr* char_at =
           new StringFromCharCodeInstr(new Value(*last), cid);
 
-  flow_graph()->AppendTo(*last, char_at, NULL, Definition::kValue);
+  flow_graph()->AppendTo(*last, char_at, NULL, FlowGraph::kValue);
   *last = char_at;
 
   return true;
 }
 
 
 void FlowGraphOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   AddReceiverCheck(call);
@@ skipping 274 matching lines @@
       }
       BinarySmiOpInstr* left_shift =
           new BinarySmiOpInstr(Token::kSHL,
                                new Value(value), new Value(count),
                                call->deopt_id(), call->token_pos());
       left_shift->set_is_truncating(true);
       if ((kBitsPerWord == 32) && (mask_value == 0xffffffffLL)) {
         // No BIT_AND operation needed.
         ReplaceCall(call, left_shift);
       } else {
-        InsertBefore(call, left_shift, call->env(), Definition::kValue);
+        InsertBefore(call, left_shift, call->env(), FlowGraph::kValue);
         BinarySmiOpInstr* bit_and =
             new BinarySmiOpInstr(Token::kBIT_AND,
                                  new Value(left_shift), new Value(int32_mask),
                                  call->deopt_id(), call->token_pos());
         ReplaceCall(call, bit_and);
       }
       return true;
     }
 
     if (HasTwoMintOrSmi(ic_data) &&
         HasOnlyOneSmi(ICData::Handle(ic_data.AsUnaryClassChecksForArgNr(1)))) {
       if (!FlowGraphCompiler::SupportsUnboxedMints() ||
           ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
         return false;
       }
       ShiftMintOpInstr* left_shift =
           new ShiftMintOpInstr(Token::kSHL,
                                new Value(value), new Value(count),
                                call->deopt_id());
-      InsertBefore(call, left_shift, call->env(), Definition::kValue);
+      InsertBefore(call, left_shift, call->env(), FlowGraph::kValue);
       BinaryMintOpInstr* bit_and =
           new BinaryMintOpInstr(Token::kBIT_AND,
                                 new Value(left_shift), new Value(int32_mask),
                                 call->deopt_id());
       ReplaceCall(call, bit_and);
       return true;
     }
   }
   return false;
 }
@@ skipping 412 matching lines @@
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                1,
                                view_cid,
                                deopt_id,
                                call->token_pos());
   cursor = flow_graph()->AppendTo(
       cursor,
       *last,
       deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
-      Definition::kValue);
+      FlowGraph::kValue);
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
     *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
     flow_graph()->AppendTo(cursor,
                            *last,
                            deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
-                           Definition::kValue);
+                           FlowGraph::kValue);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineByteArrayViewStore(const Function& target,
                                                   Instruction* call,
                                                   Definition* receiver,
                                                   intptr_t array_cid,
                                                   intptr_t view_cid,
@@ skipping 98 matching lines @@
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
                   call);
   }
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
     stored_value =
         new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
-                                    Definition::kValue);
+                                    FlowGraph::kValue);
   }
 
   StoreBarrierType needs_store_barrier = kNoStoreBarrier;
   *last = new StoreIndexedInstr(new Value(array),
                                 new Value(index),
                                 new Value(stored_value),
                                 needs_store_barrier,
                                 1,  // Index scale
                                 view_cid,
                                 call->deopt_id(),
                                 call->token_pos());
 
   flow_graph()->AppendTo(cursor,
                          *last,
                          call->deopt_id() != Isolate::kNoDeoptId ?
                             call->env() : NULL,
-                         Definition::kEffect);
+                         FlowGraph::kEffect);
   return true;
 }
 
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineByteArrayViewOp(
     Instruction* call,
     intptr_t array_cid,
     intptr_t view_cid,
     Definition** array,
     Definition* byte_index,
     Instruction** cursor) {
   // Insert byte_index smi check.
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckSmiInstr(new Value(byte_index),
                                                      call->deopt_id(),
                                                      call->token_pos()),
                                    call->env(),
-                                   Definition::kEffect);
+                                   FlowGraph::kEffect);
 
   LoadFieldInstr* length =
       new LoadFieldInstr(new Value(*array),
                          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
                          Type::ZoneHandle(Type::SmiType()),
                          call->token_pos());
   length->set_is_immutable(true);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(array_cid));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    length,
                                    NULL,
-                                   Definition::kValue);
+                                   FlowGraph::kValue);
 
   intptr_t element_size = FlowGraphCompiler::ElementSizeFor(array_cid);
   ConstantInstr* bytes_per_element =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(element_size)));
   BinarySmiOpInstr* len_in_bytes =
       new BinarySmiOpInstr(Token::kMUL,
                            new Value(length),
                            new Value(bytes_per_element),
                            call->deopt_id(), call->token_pos());
   *cursor = flow_graph()->AppendTo(*cursor, len_in_bytes, call->env(),
-                                   Definition::kValue);
+                                   FlowGraph::kValue);
 
   ConstantInstr* length_adjustment =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(
           FlowGraphCompiler::ElementSizeFor(view_cid) - 1)));
   // adjusted_length = len_in_bytes - (element_size - 1).
   BinarySmiOpInstr* adjusted_length =
       new BinarySmiOpInstr(Token::kSUB,
                            new Value(len_in_bytes),
                            new Value(length_adjustment),
                            call->deopt_id(), call->token_pos());
   *cursor = flow_graph()->AppendTo(*cursor, adjusted_length, call->env(),
-                                   Definition::kValue);
+                                   FlowGraph::kValue);
 
   // Check adjusted_length > 0.
   ConstantInstr* zero = flow_graph()->GetConstant(Smi::Handle(Smi::New(0)));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckArrayBoundInstr(
                                        new Value(adjusted_length),
                                        new Value(zero),
                                        call->deopt_id()),
                                    call->env(),
-                                   Definition::kEffect);
+                                   FlowGraph::kEffect);
   // Check 0 <= byte_index < adjusted_length.
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new CheckArrayBoundInstr(
                                        new Value(adjusted_length),
                                        new Value(byte_index),
                                        call->deopt_id()),
                                    call->env(),
-                                   Definition::kEffect);
+                                   FlowGraph::kEffect);
 
   if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements =
         new LoadUntaggedInstr(new Value(*array),
                               ExternalTypedData::data_offset());
     *cursor = flow_graph()->AppendTo(*cursor,
                                      elements,
                                      NULL,
-                                     Definition::kValue);
+                                     FlowGraph::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewLoad(InstanceCallInstr* call,
                                                 intptr_t view_cid) {
   const bool simd_view = (view_cid == kTypedDataFloat32x4ArrayCid) ||
                          (view_cid == kTypedDataInt32x4ArrayCid);
@@ skipping 227 matching lines @@
       current_iterator()->RemoveCurrentFromGraph();
       return;
     }
   }
 
   if (TypeCheckAsClassEquality(type)) {
     LoadClassIdInstr* left_cid = new LoadClassIdInstr(new Value(left));
     InsertBefore(call,
                  left_cid,
                  NULL,
-                 Definition::kValue);
+                 FlowGraph::kValue);
     const intptr_t type_cid = Class::Handle(type.type_class()).id();
     ConstantInstr* cid =
         flow_graph()->GetConstant(Smi::Handle(Smi::New(type_cid)));
 
     StrictCompareInstr* check_cid =
         new StrictCompareInstr(call->token_pos(),
                                negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
                                new Value(left_cid),
                                new Value(cid),
                                false);  // No number check.
@@ skipping 394 matching lines @@
   if (InstanceCallNeedsClassCheck(instr)) {
     AddReceiverCheck(instr);
   }
   StoreBarrierType needs_store_barrier = kEmitStoreBarrier;
   if (ArgIsAlways(kSmiCid, *instr->ic_data(), 1)) {
     InsertBefore(instr,
                  new CheckSmiInstr(new Value(instr->ArgumentAt(1)),
                                    instr->deopt_id(),
                                    instr->token_pos()),
                  instr->env(),
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
     needs_store_barrier = kNoStoreBarrier;
   }
 
   if (field.guarded_cid() != kDynamicCid) {
     InsertBefore(instr,
                  new GuardFieldInstr(new Value(instr->ArgumentAt(1)),
                                      field,
                                      instr->deopt_id()),
                  instr->env(),
-                 Definition::kEffect);
+                 FlowGraph::kEffect);
   }
 
   // Field guard was detached.
   StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
       field,
       new Value(instr->ArgumentAt(0)),
       new Value(instr->ArgumentAt(1)),
       needs_store_barrier,
       instr->token_pos());
 
@@ skipping 267 matching lines @@
 
 
 ConstraintInstr* RangeAnalysis::InsertConstraintFor(Definition* defn,
                                                     Range* constraint_range,
                                                     Instruction* after) {
   // No need to constrain constants.
   if (defn->IsConstant()) return NULL;
 
   ConstraintInstr* constraint =
       new ConstraintInstr(new Value(defn), constraint_range);
-  flow_graph_->InsertAfter(after, constraint, NULL, Definition::kValue);
+  flow_graph_->InsertAfter(after, constraint, NULL, FlowGraph::kValue);
   RenameDominatedUses(defn, constraint, constraint);
   constraints_.Add(constraint);
   return constraint;
 }
 
 
 void RangeAnalysis::ConstrainValueAfterBranch(Definition* defn, Value* use) {
   BranchInstr* branch = use->instruction()->AsBranch();
   RelationalOpInstr* rel_op = branch->comparison()->AsRelationalOp();
   if ((rel_op != NULL) && (rel_op->operation_cid() == kSmiCid)) {
@@ skipping 418 matching lines @@
               current->DebugName(),
               current->GetDeoptId(),
               current->GetBlock()->block_id(),
               pre_header->block_id());
   }
   // Move the instruction out of the loop.
   current->RemoveEnvironment();
   it->RemoveCurrentFromGraph();
   GotoInstr* last = pre_header->last_instruction()->AsGoto();
   // Using kind kEffect will not assign a fresh ssa temporary index.
-  flow_graph()->InsertBefore(last, current, last->env(), Definition::kEffect);
+  flow_graph()->InsertBefore(last, current, last->env(), FlowGraph::kEffect);
   current->deopt_id_ = last->GetDeoptId();
 }
 
 
 void LICM::TryHoistCheckSmiThroughPhi(ForwardInstructionIterator* it,
                                       BlockEntryInstr* header,
                                       BlockEntryInstr* pre_header,
                                       CheckSmiInstr* current) {
   PhiInstr* phi = current->value()->definition()->AsPhi();
   if (!header->loop_info()->Contains(phi->block()->preorder_number())) {
@@ skipping 4218 matching lines @@
           ComparisonInstr* new_comparison =
               comparison->CopyWithNewOperands(comparison->left()->Copy(),
                                               comparison->right()->Copy());
           IfThenElseInstr* if_then_else = new IfThenElseInstr(
               new_comparison,
               if_true->Copy(),
               if_false->Copy());
           flow_graph->InsertBefore(branch,
                                    if_then_else,
                                    NULL,
-                                   Definition::kValue);
+                                   FlowGraph::kValue);
 
           phi->ReplaceUsesWith(if_then_else);
 
           // Connect IfThenElseInstr to the first instruction in the merge block
           // effectively eliminating diamond control flow.
           // Current block as well as pred1 and pred2 blocks are no longer in
           // the graph at this point.
           if_then_else->LinkTo(join->next());
           pred->set_last_instruction(join->last_instruction());
 
@@ skipping 224 matching lines @@
     LoadFieldInstr* load = slots[i]->IsField()
         ? new LoadFieldInstr(new Value(alloc),
                              &Field::Cast(*slots[i]),
                              AbstractType::ZoneHandle(),
                              alloc->token_pos())
         : new LoadFieldInstr(new Value(alloc),
                              Smi::Cast(*slots[i]).Value(),
                              AbstractType::ZoneHandle(),
                              alloc->token_pos());
     flow_graph_->InsertBefore(
-        exit, load, NULL, Definition::kValue);
+        exit, load, NULL, FlowGraph::kValue);
     values->Add(new Value(load));
   }
 
   MaterializeObjectInstr* mat = new MaterializeObjectInstr(cls, slots, values);
-  flow_graph_->InsertBefore(exit, mat, NULL, Definition::kValue);
+  flow_graph_->InsertBefore(exit, mat, NULL, FlowGraph::kValue);
 
   // Replace all mentions of this allocation with a newly inserted
   // MaterializeObject instruction.
   // We must preserve the identity: all mentions are replaced by the same
   // materialization.
   for (Environment::DeepIterator env_it(exit->env());
        !env_it.Done();
        env_it.Advance()) {
     Value* use = env_it.CurrentValue();
     if (use->definition() == alloc) {
@@ skipping 39 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart