Last cross-platform cleanup in preparation of improved ARM code for indexed

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 293 matching lines @@
 }
 
 
 
 // Used by TryMergeDivMod.
 // Inserts a load-indexed instruction between a TRUNCDIV or MOD instruction,
 // and the using instruction. This is an intermediate step before merging.
 void FlowGraphOptimizer::AppendLoadIndexedForMerged(Definition* instr,
                                                     intptr_t ix,
                                                     intptr_t cid) {
-  const intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(cid);
+  const intptr_t index_scale = Instance::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, FlowGraph::kValue);
@@ skipping 969 matching lines @@
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     stored_value =
         new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     FlowGraph::kValue);
   }
 
-  intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
+  const intptr_t index_scale = Instance::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,
@@ skipping 331 matching lines @@
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Set deopt_id if we can optimistically assume that the result is Smi.
     // Assume mixed Mint/Smi if this instruction caused deoptimization once.
     deopt_id = ic_data.HasDeoptReasons() ?
         Isolate::kNoDeoptId : call->deopt_id();
   }
 
   // Array load and return.
-  intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
+  intptr_t index_scale = Instance::ElementSizeFor(array_cid);
   *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,
@@ skipping 1050 matching lines @@
   cursor = flow_graph()->AppendTo(cursor,
                                    new CheckArrayBoundInstr(new Value(length),
                                                             new Value(index),
                                                             call->deopt_id()),
                                    call->env(),
                                    FlowGraph::kEffect);
 
   LoadIndexedInstr* load_indexed = new LoadIndexedInstr(
       new Value(str),
       new Value(index),
-      FlowGraphCompiler::ElementSizeFor(cid),
+      Instance::ElementSizeFor(cid),
       cid,
       Isolate::kNoDeoptId,
       call->token_pos());
 
   cursor = flow_graph()->AppendTo(cursor,
                                   load_indexed,
                                   NULL,
                                   FlowGraph::kValue);
   ASSERT(cursor == load_indexed);
   return load_indexed;
@@ skipping 963 matching lines @@
                          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,
                                    FlowGraph::kValue);
 
-  intptr_t element_size = FlowGraphCompiler::ElementSizeFor(array_cid);
+  intptr_t element_size = Instance::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(),
                                    FlowGraph::kValue);
 
   ConstantInstr* length_adjustment =
       flow_graph()->GetConstant(Smi::Handle(Smi::New(
-          FlowGraphCompiler::ElementSizeFor(view_cid) - 1)));
+          Instance::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(),
                                    FlowGraph::kValue);
 
   // Check adjusted_length > 0.
@@ skipping 5963 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