Use enum instead of bool parameter in IL instructions to indicate if a store barrier is needed.

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 875 matching lines @@
                                   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();
     InsertBefore(call, assert_value, call->env(), Definition::kValue);
   }
 
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
-  // Check if store barrier is needed.
-  bool needs_store_barrier = !RawObject::IsByteArrayClassId(array_cid);
+  // Check if store barrier is needed. Byte arrays don't need a store barrier.
+  StoreBarrierType needs_store_barrier =
+      RawObject::IsByteArrayClassId(array_cid)
+          ? kNoStoreBarrier
+          : kEmitStoreBarrier;
   if (!value_check.IsNull()) {
-    needs_store_barrier = false;
+    // No store barrier needed because checked value is a smi, an unboxed mint
+    // or unboxed double.
+    needs_store_barrier = kNoStoreBarrier;
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
                   call);
   }
 
   Definition* array_op = new StoreIndexedInstr(new Value(array),
                                                new Value(index),
                                                new Value(stored_value),
                                                needs_store_barrier,
                                                array_cid,
                                                call->deopt_id());
@@ skipping 989 matching lines @@
   }
   // Inline implicit instance setter.
   const String& field_name =
       String::Handle(Field::NameFromSetter(instr->function_name()));
   const Field& field = Field::Handle(GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(instr)) {
     AddReceiverCheck(instr);
   }
-  bool needs_store_barrier = true;
+  StoreBarrierType needs_store_barrier = kEmitStoreBarrier;
   if (ArgIsAlwaysSmi(*instr->ic_data(), 1)) {
     InsertBefore(instr,
                  new CheckSmiInstr(new Value(instr->ArgumentAt(1)),
                                    instr->deopt_id()),
                  instr->env(),
                  Definition::kEffect);
-    needs_store_barrier = false;
+    needs_store_barrier = kNoStoreBarrier;
   }
   StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
       field,
       new Value(instr->ArgumentAt(0)),
       new Value(instr->ArgumentAt(1)),
       needs_store_barrier);
   // Detach environment from the original instruction because it can't
   // deoptimize.
   for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
@@ skipping 2450 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart