VM: Remove dead code from flow graph optimizer.

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/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 31 matching lines @@
 DEFINE_FLAG(bool, truncating_left_shift, true,
     "Optimize left shift to truncate if possible");
 DEFINE_FLAG(bool, use_cha_deopt, true,
     "Use class hierarchy analysis even if it can cause deoptimization.");
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_IA32)
 DEFINE_FLAG(bool, trace_smi_widening, false, "Trace Smi->Int32 widening pass.");
 #endif
 
 DECLARE_FLAG(bool, precompilation);
 DECLARE_FLAG(bool, polymorphic_with_deopt);
-DECLARE_FLAG(bool, source_lines);
 DECLARE_FLAG(bool, trace_cha);
 DECLARE_FLAG(bool, trace_field_guards);
-DECLARE_FLAG(bool, trace_type_check_elimination);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
@@ skipping 345 matching lines @@
     BinarySmiOpInstr* smi_op = new(Z) BinarySmiOpInstr(
         Token::kBIT_AND,
         new(Z) Value(left_instr),
         new(Z) Value(right_instr),
         Thread::kNoDeoptId);  // BIT_AND cannot deoptimize.
     bit_and_instr->ReplaceWith(smi_op, current_iterator());
   }
 }
 
 
-
-// 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 = Instance::ElementSizeFor(cid);
-  ConstantInstr* index_instr =
-      flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(ix)));
-  LoadIndexedInstr* load =
-      new(Z) LoadIndexedInstr(new(Z) Value(instr),
-                                      new(Z) Value(index_instr),
-                                      index_scale,
-                                      cid,
-                                      Thread::kNoDeoptId,
-                                      instr->token_pos());
-  instr->ReplaceUsesWith(load);
-  flow_graph()->InsertAfter(instr, load, NULL, FlowGraph::kValue);
-}
-
-
 void FlowGraphOptimizer::AppendExtractNthOutputForMerged(Definition* instr,
                                                          intptr_t index,
                                                          Representation rep,
                                                          intptr_t cid) {
   ExtractNthOutputInstr* extract =
       new(Z) ExtractNthOutputInstr(new(Z) Value(instr), index, rep, cid);
   instr->ReplaceUsesWith(extract);
   flow_graph()->InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
@@ skipping 1054 matching lines @@
     case MethodRecognizer::kFloat64x2ArraySetIndexed:
       if (!ShouldInlineSimd()) {
         return false;
       }
       value_check = ic_data.AsUnaryClassChecksForCid(kFloat64x2Cid, target);
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               value_check, entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt8:
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataInt8ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint8:
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataUint8ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt16:
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataInt16ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint16:
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataUint16ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt32:
       if (!CanUnboxInt32()) {
         return false;
       }
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataInt32ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint32:
       if (!CanUnboxInt32()) {
         return false;
       }
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataUint32ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat32:
       if (!CanUnboxDouble()) {
         return false;
       }
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat32ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat64:
       if (!CanUnboxDouble()) {
         return false;
       }
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat64ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat32x4:
       if (!ShouldInlineSimd()) {
         return false;
       }
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat32x4ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt32x4:
       if (!ShouldInlineSimd()) {
         return false;
       }
       return InlineByteArrayBaseLoad(call, receiver, receiver_cid,
                                      kTypedDataInt32x4ArrayCid,
-                                     ic_data, entry, last);
+                                     entry, last);
     case MethodRecognizer::kByteArrayBaseSetInt8:
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataInt8ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetUint8:
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataUint8ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetInt16:
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataInt16ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetUint16:
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataUint16ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetInt32:
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataInt32ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetUint32:
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataUint32ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetFloat32:
       if (!CanUnboxDouble()) {
         return false;
       }
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataFloat32ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetFloat64:
       if (!CanUnboxDouble()) {
         return false;
       }
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataFloat64ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetFloat32x4:
       if (!ShouldInlineSimd()) {
         return false;
       }
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataFloat32x4ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kByteArrayBaseSetInt32x4:
       if (!ShouldInlineSimd()) {
         return false;
       }
       return InlineByteArrayBaseStore(target, call, receiver, receiver_cid,
                                       kTypedDataInt32x4ArrayCid,
-                                      ic_data, entry, last);
+                                      entry, last);
     case MethodRecognizer::kStringBaseCodeUnitAt:
       return InlineStringCodeUnitAt(call, receiver_cid, entry, last);
     case MethodRecognizer::kStringBaseCharAt:
       return InlineStringBaseCharAt(call, receiver_cid, entry, last);
     case MethodRecognizer::kDoubleAdd:
       return InlineDoubleOp(Token::kADD, call, entry, last);
     case MethodRecognizer::kDoubleSub:
       return InlineDoubleOp(Token::kSUB, call, entry, last);
     case MethodRecognizer::kDoubleMul:
       return InlineDoubleOp(Token::kMUL, call, entry, last);
@@ skipping 1908 matching lines @@
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::InlineByteArrayBaseLoad(Instruction* call,
                                                  Definition* receiver,
                                                  intptr_t array_cid,
                                                  intptr_t view_cid,
-                                                 const ICData& ic_data,
                                                  TargetEntryInstr** entry,
                                                  Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   *entry = new(Z) TargetEntryInstr(flow_graph()->allocate_block_id(),
                                    call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
@@ skipping 32 matching lines @@
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineByteArrayBaseStore(const Function& target,
                                                   Instruction* call,
                                                   Definition* receiver,
                                                   intptr_t array_cid,
                                                   intptr_t view_cid,
-                                                  const ICData& ic_data,
                                                   TargetEntryInstr** entry,
                                                   Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   *entry = new(Z) TargetEntryInstr(flow_graph()->allocate_block_id(),
                                    call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
@@ skipping 1409 matching lines @@
 }
 #else
 void FlowGraphOptimizer::WidenSmiToInt32() {
   // TODO(vegorov) ideally on 64-bit platforms we would like to narrow smi
   // operations to 32-bit where it saves tagging and untagging and allows
   // to use shorted (and faster) instructions. But we currently don't
   // save enough range information in the ICData to drive this decision.
 }
 #endif
 
-void FlowGraphOptimizer::InferIntRanges() {
-  RangeAnalysis range_analysis(flow_graph_);
-  range_analysis.Analyze();
-}
-
 
 void FlowGraphOptimizer::EliminateEnvironments() {
   // After this pass we can no longer perform LICM and hoist instructions
   // that can deoptimize.
 
   flow_graph_->disallow_licm();
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* block = block_order_[i];
     block->RemoveEnvironment();
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
       if (!current->CanDeoptimize()) {
         // TODO(srdjan): --source-lines needs deopt environments to get at
         // the code for this instruction, however, leaving the environment
         // changes code.
         current->RemoveEnvironment();
       }
     }
   }
 }
 
 
 }  // namespace dart