VM: More refactoring of recognized methods inlining.

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/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 2042 matching lines @@
   return changed;
 }
 
 
 // Optimize (a << b) & c pattern: if c is a positive Smi or zero, then the
 // shift can be a truncating Smi shift-left and result is always Smi.
 // Merging occurs only per basic-block.
 void FlowGraph::TryOptimizePatterns() {
   if (!FLAG_truncating_left_shift) return;
   GrowableArray<BinarySmiOpInstr*> div_mod_merge;
-  GrowableArray<MathUnaryInstr*> sin_cos_merge;
+  GrowableArray<InvokeMathCFunctionInstr*> sin_cos_merge;
   for (BlockIterator block_it = reverse_postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     // Merging only per basic-block.
     div_mod_merge.Clear();
     sin_cos_merge.Clear();
     ForwardInstructionIterator it(block_it.Current());
     for (; !it.Done(); it.Advance()) {
       if (it.Current()->IsBinarySmiOp()) {
         BinarySmiOpInstr* binop = it.Current()->AsBinarySmiOp();
         if (binop->op_kind() == Token::kBIT_AND) {
           OptimizeLeftShiftBitAndSmiOp(&it,
                                        binop,
                                        binop->left()->definition(),
                                        binop->right()->definition());
         } else if ((binop->op_kind() == Token::kTRUNCDIV) ||
                    (binop->op_kind() == Token::kMOD)) {
           if (binop->HasUses()) {
             div_mod_merge.Add(binop);
           }
         }
       } else if (it.Current()->IsBinaryMintOp()) {
         BinaryMintOpInstr* mintop = it.Current()->AsBinaryMintOp();
         if (mintop->op_kind() == Token::kBIT_AND) {
           OptimizeLeftShiftBitAndSmiOp(&it,
                                        mintop,
                                        mintop->left()->definition(),
                                        mintop->right()->definition());
         }
-      } else if (it.Current()->IsMathUnary()) {
-        MathUnaryInstr* math_unary = it.Current()->AsMathUnary();
-        if ((math_unary->kind() == MathUnaryInstr::kSin) ||
-            (math_unary->kind() == MathUnaryInstr::kCos)) {
+      } else if (it.Current()->IsInvokeMathCFunction()) {
+        InvokeMathCFunctionInstr* math_unary =
+            it.Current()->AsInvokeMathCFunction();
+        if ((math_unary->recognized_kind() == MethodRecognizer::kMathSin) ||
+            (math_unary->recognized_kind() == MethodRecognizer::kMathCos)) {
           if (math_unary->HasUses()) {
             sin_cos_merge.Add(math_unary);
           }
         }
       }
     }
     TryMergeTruncDivMod(&div_mod_merge);
     TryMergeMathUnary(&sin_cos_merge);
   }
 }
@@ skipping 81 matching lines @@
   }
   for (intptr_t i = 0; i < merge_candidates->length(); i++) {
     BinarySmiOpInstr* curr_instr = (*merge_candidates)[i];
     if (curr_instr == NULL) {
       // Instruction was merged already.
       continue;
     }
     ASSERT((curr_instr->op_kind() == Token::kTRUNCDIV) ||
            (curr_instr->op_kind() == Token::kMOD));
     // Check if there is kMOD/kTRUNDIV binop with same inputs.
-    const intptr_t other_kind = (curr_instr->op_kind() == Token::kTRUNCDIV) ?
+    const Token::Kind other_kind = (curr_instr->op_kind() == Token::kTRUNCDIV) ?
         Token::kMOD : Token::kTRUNCDIV;
     Definition* left_def = curr_instr->left()->definition();
     Definition* right_def = curr_instr->right()->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
       BinarySmiOpInstr* other_binop = (*merge_candidates)[k];
       // 'other_binop' can be NULL if it was already merged.
       if ((other_binop != NULL) &&
           (other_binop->op_kind() == other_kind) &&
           (other_binop->left()->definition() == left_def) &&
           (other_binop->right()->definition() == right_def)) {
@@ skipping 26 matching lines @@
         // TODO(srdjan): Allow merging of trunc-div/mod into truncDivMod.
         break;
       }
     }
   }
 }
 
 
 // Tries to merge MathUnary operations, in this case sine and cosine.
 void FlowGraph::TryMergeMathUnary(
-    GrowableArray<MathUnaryInstr*>* merge_candidates) {
+    GrowableArray<InvokeMathCFunctionInstr*>* merge_candidates) {
   if (!FlowGraphCompiler::SupportsSinCos() || !CanUnboxDouble() ||
       !FLAG_merge_sin_cos) {
     return;
   }
   if (merge_candidates->length() < 2) {
     // Need at least a SIN and a COS.
     return;
   }
   for (intptr_t i = 0; i < merge_candidates->length(); i++) {
-    MathUnaryInstr* curr_instr = (*merge_candidates)[i];
+    InvokeMathCFunctionInstr* curr_instr = (*merge_candidates)[i];
     if (curr_instr == NULL) {
       // Instruction was merged already.
       continue;
     }
-    const intptr_t kind = curr_instr->kind();
-    ASSERT((kind == MathUnaryInstr::kSin) ||
-           (kind == MathUnaryInstr::kCos));
+    const MethodRecognizer::Kind kind = curr_instr->recognized_kind();
+    ASSERT((kind == MethodRecognizer::kMathSin) ||
+           (kind == MethodRecognizer::kMathCos));
     // Check if there is sin/cos binop with same inputs.
-    const intptr_t other_kind = (kind == MathUnaryInstr::kSin) ?
-        MathUnaryInstr::kCos : MathUnaryInstr::kSin;
-    Definition* def = curr_instr->value()->definition();
+    const MethodRecognizer::Kind other_kind =
+        (kind == MethodRecognizer::kMathSin)
+        ? MethodRecognizer::kMathCos : MethodRecognizer::kMathSin;
+    Definition* def = curr_instr->InputAt(0)->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
-      MathUnaryInstr* other_op = (*merge_candidates)[k];
+      InvokeMathCFunctionInstr* other_op = (*merge_candidates)[k];
       // 'other_op' can be NULL if it was already merged.
-      if ((other_op != NULL) && (other_op->kind() == other_kind) &&
-          (other_op->value()->definition() == def)) {
+      if ((other_op != NULL) && (other_op->recognized_kind() == other_kind) &&
+          (other_op->InputAt(0)->definition() == def)) {
         (*merge_candidates)[k] = NULL;  // Clear it.
         ASSERT(curr_instr->HasUses());
         AppendExtractNthOutputForMerged(curr_instr,
                                         MergedMathInstr::OutputIndexOf(kind),
                                         kUnboxedDouble, kDoubleCid);
         ASSERT(other_op->HasUses());
         AppendExtractNthOutputForMerged(
             other_op,
             MergedMathInstr::OutputIndexOf(other_kind),
             kUnboxedDouble, kDoubleCid);
         ZoneGrowableArray<Value*>* args = new(Z) ZoneGrowableArray<Value*>(1);
-        args->Add(new(Z) Value(curr_instr->value()->definition()));
+        args->Add(new(Z) Value(curr_instr->InputAt(0)->definition()));
         // Replace with SinCos.
         MergedMathInstr* sin_cos =
             new(Z) MergedMathInstr(args,
                                    curr_instr->DeoptimizationTarget(),
                                    MergedMathInstr::kSinCos);
         curr_instr->ReplaceWith(sin_cos, NULL);
         other_op->ReplaceUsesWith(sin_cos);
         other_op->RemoveFromGraph();
         // Only one merge possible. Because canonicalization happens later,
         // more candidates are possible.
@@ skipping 12 matching lines @@
   ExtractNthOutputInstr* extract =
       new(Z) ExtractNthOutputInstr(new(Z) Value(instr), index, rep, cid);
   instr->ReplaceUsesWith(extract);
   InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 
 
 
 }  // namespace dart