Improve polymorphic inlining of int/int double/double operations.

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 1542 matching lines @@
       if (!ShouldInlineSimd()) {
         return false;
       }
       return InlineByteArrayViewStore(target, call, receiver, receiver_cid,
                                       kTypedDataInt32x4ArrayCid,
                                       ic_data, 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, receiver_cid, entry, last);
+    case MethodRecognizer::kDoubleSub:
+      return InlineDoubleOp(Token::kSUB, call, receiver_cid, entry, last);
+    case MethodRecognizer::kDoubleMul:
+      return InlineDoubleOp(Token::kMUL, call, receiver_cid, entry, last);
+    case MethodRecognizer::kDoubleDiv:
+      return InlineDoubleOp(Token::kDIV, call, receiver_cid, entry, last);
     default:
       return false;
   }
 }
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineIndexedOp(Instruction* call,
                                                     intptr_t array_cid,
                                                     Definition** array,
                                                     Definition* index,
@@ skipping 756 matching lines @@
     // Reset value types if guarded_cid was used.
     for (Value::Iterator it(load->input_use_list());
          !it.Done();
          it.Advance()) {
       it.Current()->SetReachingType(NULL);
     }
   }
 }
 
 
-LoadFieldInstr* FlowGraphOptimizer::BuildLoadStringLength(Definition* str) {
-  // Treat length loads as mutable (i.e. affected by side effects) to avoid
-  // hoisting them since we can't hoist the preceding class-check. This
-  // is because of externalization of strings that affects their class-id.
-  LoadFieldInstr* load = new(I) LoadFieldInstr(
-      new(I) Value(str),
-      String::length_offset(),
-      Type::ZoneHandle(I, Type::SmiType()),
-      str->token_pos());
-  load->set_result_cid(kSmiCid);
-  load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
-  return load;
-}
-
-
 bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     I, call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
@@ skipping 340 matching lines @@
 
   cursor = flow_graph()->AppendTo(cursor,
                                   new(I) CheckSmiInstr(
                                       new(I) Value(index),
                                       call->deopt_id(),
                                       call->token_pos()),
                                   call->env(),
                                   FlowGraph::kEffect);
 
   // Load the length of the string.
-  LoadFieldInstr* length = BuildLoadStringLength(str);
+  // Treat length loads as mutable (i.e. affected by side effects) to avoid
+  // hoisting them since we can't hoist the preceding class-check. This
+  // is because of externalization of strings that affects their class-id.
+  LoadFieldInstr* length = new(I) LoadFieldInstr(
+      new(I) Value(str),
+      String::length_offset(),
+      Type::ZoneHandle(I, Type::SmiType()),
+      str->token_pos());
+  length->set_result_cid(kSmiCid);
+  length->set_recognized_kind(MethodRecognizer::kStringBaseLength);
+
   cursor = flow_graph()->AppendTo(cursor, length, NULL, FlowGraph::kValue);
   // Bounds check.
   cursor = flow_graph()->AppendTo(cursor,
                                    new(I) CheckArrayBoundInstr(
                                        new(I) Value(length),
                                        new(I) Value(index),
                                        call->deopt_id()),
                                    call->env(),
                                    FlowGraph::kEffect);
 
@@ skipping 58 matching lines @@
   StringFromCharCodeInstr* char_at = new(I) StringFromCharCodeInstr(
       new(I) Value(*last), cid);
 
   flow_graph()->AppendTo(*last, char_at, NULL, FlowGraph::kValue);
   *last = char_at;
 
   return true;
 }
 
 
+bool FlowGraphOptimizer::InlineDoubleOp(
+    Token::Kind op_kind,
+    Instruction* call,
+    intptr_t cid,  // Not used.

[srdjan, 2014/08/18 18:04:49]

Why pass if not used?

[Florian Schneider, 2014/08/18 18:22:57]

Done.

+    TargetEntryInstr** entry,
+    Definition** last) {
+  Definition* left = call->ArgumentAt(0);
+  Definition* right = call->ArgumentAt(1);
+
+  *entry = new(I) TargetEntryInstr(flow_graph()->allocate_block_id(),
+                                   call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(I, call);
+  // Arguments are checked. No need for class check.
+  BinaryDoubleOpInstr* double_bin_op =
+      new(I) BinaryDoubleOpInstr(op_kind,
+                                 new(I) Value(left),
+                                 new(I) Value(right),
+                                 call->deopt_id(), call->token_pos());
+  flow_graph()->AppendTo(*entry, double_bin_op, call->env(), FlowGraph::kValue);
+  *last = double_bin_op;
+
+  return true;
+}
+
+
 void FlowGraphOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   AddReceiverCheck(call);
   ZoneGrowableArray<Value*>* args =
       new(I) ZoneGrowableArray<Value*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
     args->Add(new(I) Value(call->ArgumentAt(i)));
   }
   InvokeMathCFunctionInstr* invoke =
@@ skipping 150 matching lines @@
         if (!TargetCPUFeatures::double_truncate_round_supported()) {
           ReplaceWithMathCFunction(call, recognized_kind);
         } else {
           AddReceiverCheck(call);
           DoubleToDoubleInstr* d2d_instr =
               new(I) DoubleToDoubleInstr(new(I) Value(call->ArgumentAt(0)),
                                          recognized_kind, call->deopt_id());
           ReplaceCall(call, d2d_instr);
         }
         return true;
+      case MethodRecognizer::kDoubleAdd:
+      case MethodRecognizer::kDoubleSub:
+      case MethodRecognizer::kDoubleMul:
+      case MethodRecognizer::kDoubleDiv:
+        return TryReplaceInstanceCallWithInline(call);
       default:
         // Unsupported method.
         return false;
     }
   }
 
   if (IsSupportedByteArrayViewCid(class_ids[0]) &&
       (ic_data.NumberOfChecks() == 1)) {
     // For elements that may not fit into a smi on all platforms, check if
     // elements fit into a smi or the platform supports unboxed mints.
@@ skipping 1362 matching lines @@
                                         call->deopt_id(),
                                         recognized_kind,
                                         call->token_pos());
     ReplaceCall(call, invoke);
   } else if (recognized_kind == MethodRecognizer::kObjectArrayConstructor) {
     Value* type = new(I) Value(call->ArgumentAt(0));
     Value* num_elements = new(I) Value(call->ArgumentAt(1));
     CreateArrayInstr* create_array =
         new(I) CreateArrayInstr(call->token_pos(), type, num_elements);
     ReplaceCall(call, create_array);
+  } else if (recognized_kind == MethodRecognizer::kDoubleFromInteger) {
+    if (call->HasICData() && (call->ic_data()->NumberOfChecks() == 1)) {
+      const ICData& ic_data = *call->ic_data();
+      if (CanUnboxDouble() && ArgIsAlways(kSmiCid, ic_data, 0)) {
+        Definition* arg = call->ArgumentAt(0);
+        InsertBefore(call,
+                     new(I) CheckSmiInstr(
+                         new(I) Value(arg),
+                         call->deopt_id(),
+                         call->token_pos()),
+                     call->env(),
+                     FlowGraph::kEffect);
+        ReplaceCall(call,
+                    new(I) SmiToDoubleInstr(new(I) Value(arg),
+                                            call->token_pos()));
+      }
+    }
   } else if (call->function().IsFactory()) {
     const Class& function_class =
         Class::Handle(I, call->function().Owner());
     if ((function_class.library() == Library::CoreLibrary()) ||
         (function_class.library() == Library::TypedDataLibrary())) {
       intptr_t cid = FactoryRecognizer::ResultCid(call->function());
       switch (cid) {
         case kArrayCid: {
           Value* type = new(I) Value(call->ArgumentAt(0));
           Value* num_elements = new(I) Value(call->ArgumentAt(1));
@@ skipping 5187 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart