VM: More refactoring of recognized methods inlining.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
@@ skipping 2334 matching lines @@
                        FlowGraph::kEffect);
   return true;
 }
 
 
 static bool InlineDoubleOp(FlowGraph* flow_graph,
                            Token::Kind op_kind,
                            Instruction* call,
                            TargetEntryInstr** entry,
                            Definition** last) {
+  if (!CanUnboxDouble()) {
+    return false;
+  }
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                    call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   // Arguments are checked. No need for class check.
   BinaryDoubleOpInstr* double_bin_op =
       new(Z) BinaryDoubleOpInstr(op_kind,
                                  new(Z) Value(left),
@@ skipping 49 matching lines @@
       new(Z) Value(value),
       store_barrier_type,
       call->token_pos());
   flow_graph->AppendTo(*entry, store, call->env(), FlowGraph::kEffect);
   *last = store;
 
   return true;
 }
 
 
-static intptr_t PrepareInlineByteArrayBaseOp(
+static void PrepareInlineByteArrayBaseOp(
     FlowGraph* flow_graph,
     Instruction* call,
     intptr_t array_cid,
     intptr_t view_cid,
     Definition** array,
     Definition* byte_index,
     Instruction** cursor) {
   LoadFieldInstr* length =
       new(Z) LoadFieldInstr(
           new(Z) Value(*array),
@@ skipping 57 matching lines @@
   if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements =
         new(Z) LoadUntaggedInstr(new(Z) Value(*array),
                                  ExternalTypedData::data_offset());
     *cursor = flow_graph->AppendTo(*cursor,
                                    elements,
                                    NULL,
                                    FlowGraph::kValue);
     *array = elements;
   }
-  return array_cid;
 }
 
 
 static bool InlineByteArrayBaseLoad(FlowGraph* flow_graph,
                                     Instruction* call,
                                     Definition* receiver,
                                     intptr_t array_cid,
                                     intptr_t view_cid,
                                     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;
 
-  array_cid = PrepareInlineByteArrayBaseOp(flow_graph,
-                                           call,
-                                           array_cid,
-                                           view_cid,
-                                           &array,
-                                           index,
-                                           &cursor);
+  PrepareInlineByteArrayBaseOp(flow_graph,
+                               call,
+                               array_cid,
+                               view_cid,
+                               &array,
+                               index,
+                               &cursor);
 
   intptr_t deopt_id = Thread::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Deoptimization may be needed if result does not always fit in a Smi.
     deopt_id = (kSmiBits >= 32) ? Thread::kNoDeoptId : call->deopt_id();
   }
 
   *last = new(Z) LoadIndexedInstr(new(Z) Value(array),
                                   new(Z) Value(index),
@@ skipping 27 matching lines @@
                                      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;
 
-  array_cid = PrepareInlineByteArrayBaseOp(flow_graph,
-                                           call,
-                                           array_cid,
-                                           view_cid,
-                                           &array,
-                                           index,
-                                           &cursor);
+  PrepareInlineByteArrayBaseOp(flow_graph,
+                               call,
+                               array_cid,
+                               view_cid,
+                               &array,
+                               index,
+                               &cursor);
 
   // Extract the instance call so we can use the function_name in the stored
   // value check ICData.
   InstanceCallInstr* i_call = NULL;
   if (call->IsPolymorphicInstanceCall()) {
     i_call = call->AsPolymorphicInstanceCall()->instance_call();
   } else {
     ASSERT(call->IsInstanceCall());
     i_call = call->AsInstanceCall();
   }
@@ skipping 275 matching lines @@
       flow_graph->InsertBefore(call, check, call->env(), FlowGraph::kEffect);
     }
 
     // Remove the original push arguments.
     for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
     }
     // Replace all uses of this definition with the result.
-    call->ReplaceUsesWith(last);
+    if (call->HasUses()) {
+      call->ReplaceUsesWith(last);
+    }
     // Finally insert the sequence other definition in place of this one in the
     // graph.
-    call->previous()->LinkTo(entry->next());
+    if (entry->next() != NULL) {
+      call->previous()->LinkTo(entry->next());
+    }
     entry->UnuseAllInputs();  // Entry block is not in the graph.
-    last->LinkTo(call);
+    if (last != NULL) {
+      last->LinkTo(call);
+    }
     // Remove through the iterator.
     ASSERT(iterator->Current() == call);
     iterator->RemoveCurrentFromGraph();
     call->set_previous(NULL);
     call->set_next(NULL);
     return true;
   }
   return false;
 }
 
@@ skipping 12 matching lines @@
                                                   call->token_pos(),
                                                   *call->ic_data(),
                                                   &entry, &last)) {
     // Remove the original push arguments.
     for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
     }
     // Replace all uses of this definition with the result.
-    call->ReplaceUsesWith(last);
+    if (call->HasUses()) {
+      call->ReplaceUsesWith(last);
+    }
     // Finally insert the sequence other definition in place of this one in the
     // graph.
-    call->previous()->LinkTo(entry->next());
+    if (entry->next() != NULL) {
+      call->previous()->LinkTo(entry->next());
+    }
     entry->UnuseAllInputs();  // Entry block is not in the graph.
-    last->LinkTo(call);
+    if (last != NULL) {
+      last->LinkTo(call);
+    }
     // Remove through the iterator.
     ASSERT(iterator->Current() == call);
     iterator->RemoveCurrentFromGraph();
     call->set_previous(NULL);
     call->set_next(NULL);
     return true;
   }
   return false;
 }
 
@@ skipping 389 matching lines @@
       return false;
   }
   flow_graph->AppendTo(cursor, *last,
                        call->deopt_id() != Thread::kNoDeoptId ?
                        call->env() : NULL,
                        FlowGraph::kValue);
   return true;
 }
 
 
+static bool InlineMathCFunction(FlowGraph* flow_graph,
+                                Instruction* call,
+                                MethodRecognizer::Kind kind,
+                                TargetEntryInstr** entry,
+                                Definition** last) {
+  if (!CanUnboxDouble()) {
+    return false;
+  }
+  *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
+                                   call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(Z, call);
+  Instruction* cursor = *entry;
+
+  switch (kind) {
+    case MethodRecognizer::kMathSqrt: {
+      *last = new(Z) MathUnaryInstr(MathUnaryInstr::kSqrt,
+                                    new(Z) Value(call->ArgumentAt(0)),
+                                    call->deopt_id());
+      break;
+    }
+    default: {
+      ZoneGrowableArray<Value*>* args =
+          new(Z) ZoneGrowableArray<Value*>(call->ArgumentCount());
+      for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
+        args->Add(new(Z) Value(call->ArgumentAt(i)));
+      }
+      *last = new(Z) InvokeMathCFunctionInstr(args,
+                                              call->deopt_id(),
+                                              kind,
+                                              call->token_pos());
+      break;
+    }
+  }
+  flow_graph->AppendTo(cursor, *last,
+                       call->deopt_id() != Thread::kNoDeoptId ?
+                       call->env() : NULL,
+                       FlowGraph::kValue);
+  return true;
+}
+
+
 bool FlowGraphInliner::TryInlineRecognizedMethod(FlowGraph* flow_graph,
                                                  intptr_t receiver_cid,
                                                  const Function& target,
-                                                 Instruction* call,
+                                                 Definition* call,
                                                  Definition* receiver,
                                                  TokenPosition token_pos,
                                                  const ICData& ic_data,
                                                  TargetEntryInstr** entry,
                                                  Definition** last) {
   ICData& value_check = ICData::ZoneHandle(Z);
   MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(target);
   switch (kind) {
     // Recognized [] operators.
     case MethodRecognizer::kImmutableArrayGetIndexed:
@@ skipping 302 matching lines @@
     case MethodRecognizer::kFloat32x4FromFloat64x2:
     case MethodRecognizer::kFloat64x2Constructor:
     case MethodRecognizer::kFloat64x2Zero:
     case MethodRecognizer::kFloat64x2Splat:
     case MethodRecognizer::kFloat64x2FromFloat32x4:
     case MethodRecognizer::kInt32x4BoolConstructor:
     case MethodRecognizer::kInt32x4Constructor:
     case MethodRecognizer::kInt32x4FromFloat32x4Bits:
       return InlineSimdConstructor(flow_graph, call, kind, entry, last);
 
+    case MethodRecognizer::kMathSqrt:
+    case MethodRecognizer::kMathDoublePow:
+    case MethodRecognizer::kMathSin:
+    case MethodRecognizer::kMathCos:
+    case MethodRecognizer::kMathTan:
+    case MethodRecognizer::kMathAsin:
+    case MethodRecognizer::kMathAcos:
+    case MethodRecognizer::kMathAtan:
+    case MethodRecognizer::kMathAtan2:
+      return InlineMathCFunction(flow_graph, call, kind, entry, last);
+
+    case MethodRecognizer::kObjectConstructor: {
+      *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
+                                       call->GetBlock()->try_index());
+      (*entry)->InheritDeoptTarget(Z, call);
+      ASSERT(!call->HasUses());
+      *last = NULL;  // Empty body.
+      return true;
+    }
+
+    case MethodRecognizer::kObjectArrayAllocate: {
+      Value* num_elements = new(Z) Value(call->ArgumentAt(1));
+      if (num_elements->BindsToConstant() &&
+          num_elements->BoundConstant().IsSmi()) {
+        intptr_t length =
+            Smi::Cast(num_elements->BoundConstant()).Value();
+        if (length >= 0 && length <= Array::kMaxElements) {
+          Value* type = new(Z) Value(call->ArgumentAt(0));
+          *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+          (*entry)->InheritDeoptTarget(Z, call);
+          *last =
+              new(Z) CreateArrayInstr(call->token_pos(), type, num_elements);
+          flow_graph->AppendTo(*entry, *last,
+                               call->deopt_id() != Thread::kNoDeoptId ?
+                               call->env() : NULL,
+                               FlowGraph::kValue);
+          return true;
+        }
+      }
+      return false;
+    }
+
+    case MethodRecognizer::kOneByteStringSetAt: {
+      // This is an internal method, no need to check argument types nor
+      // range.
+      *entry = new(Z) TargetEntryInstr(flow_graph->allocate_block_id(),
+                                       call->GetBlock()->try_index());
+      (*entry)->InheritDeoptTarget(Z, call);
+      Definition* str = call->ArgumentAt(0);
+      Definition* index = call->ArgumentAt(1);
+      Definition* value = call->ArgumentAt(2);
+      *last = new(Z) StoreIndexedInstr(
+          new(Z) Value(str),
+          new(Z) Value(index),
+          new(Z) Value(value),
+          kNoStoreBarrier,
+          1,  // Index scale
+          kOneByteStringCid,
+          call->deopt_id(),
+          call->token_pos());
+      flow_graph->AppendTo(*entry,
+                           *last,
+                           call->deopt_id() != Thread::kNoDeoptId ?
+                              call->env() : NULL,
+                           FlowGraph::kEffect);
+      return true;
+    }
+
     default:
       return false;
   }
 }
 
 
 }  // namespace dart