Add graph intrinsics for many math library functions

runtime/vm/intrinsifier.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.
 // Class for intrinsifying functions.
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/intrinsifier.h"
 #include "vm/object.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, intrinsify, true, "Instrinsify when possible");
+DEFINE_FLAG(bool, trace_intrinsifier, false, "Trace intrinsifier");
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 
 bool Intrinsifier::CanIntrinsify(const Function& function) {
+  if (FLAG_trace_intrinsifier) {
+    THR_Print("CanIntrinsify %s ->", function.ToQualifiedCString());
+  }
   if (!FLAG_intrinsify) return false;
-  if (function.IsClosureFunction()) return false;
+  if (function.IsClosureFunction()) {
+    if (FLAG_trace_intrinsifier) {
+      THR_Print("No, closure function.\n");
+    }
+    return false;
+  }
   // Can occur because of compile-all flag.
-  if (function.is_external()) return false;
-  return function.is_intrinsic();
+  if (function.is_external()) {
+    if (FLAG_trace_intrinsifier) {
+      THR_Print("No, external function.\n");
+    }
+    return false;
+  }
+  if (!function.is_intrinsic()) {
+    if (FLAG_trace_intrinsifier) {
+      THR_Print("No, not intrinsic function.\n");
+    }
+    return false;
+  }
+  if (FLAG_trace_intrinsifier) {
+    THR_Print("Yes.\n");
+  }
+  return true;
 }
 
 
 #if defined(DART_NO_SNAPSHOT)
 void Intrinsifier::InitializeState() {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Library& lib = Library::Handle(zone);
   Class& cls = Class::Handle(zone);
   Function& func = Function::Handle(zone);
@@ skipping 27 matching lines @@
   lib = Library::CoreLibrary();
   ASSERT(!lib.IsNull());
   CORE_LIB_INTRINSIC_LIST(SETUP_FUNCTION);
   CORE_INTEGER_LIB_INTRINSIC_LIST(SETUP_FUNCTION);
   GRAPH_CORE_INTRINSICS_LIST(SETUP_FUNCTION);
 
   // Set up all math lib functions that can be intrinsified.
   lib = Library::MathLibrary();
   ASSERT(!lib.IsNull());
   MATH_LIB_INTRINSIC_LIST(SETUP_FUNCTION);
+  GRAPH_MATH_LIB_INTRINSIC_LIST(SETUP_FUNCTION);
 
   // Set up all dart:typed_data lib functions that can be intrinsified.
   lib = Library::TypedDataLibrary();
   ASSERT(!lib.IsNull());
   TYPED_DATA_LIB_INTRINSIC_LIST(SETUP_FUNCTION);
   GRAPH_TYPED_DATA_INTRINSICS_LIST(SETUP_FUNCTION);
 
   // Setup all dart:developer lib functions that can be intrinsified.
   lib = Library::DeveloperLibrary();
   ASSERT(!lib.IsNull());
   DEVELOPER_LIB_INTRINSIC_LIST(SETUP_FUNCTION);
 
 #undef SETUP_FUNCTION
 }
 #endif  // defined(DART_NO_SNAPSHOT).
 
 
 static void EmitCodeFor(FlowGraphCompiler* compiler,
                         FlowGraph* graph) {
   // The FlowGraph here is constructed by the intrinsics builder methods, and
   // is different from compiler->flow_graph(), the original method's flow graph.
-  compiler->assembler()->Comment("Graph intrinsic");
+  compiler->assembler()->Comment("Graph intrinsic begin");
   for (intptr_t i = 0; i < graph->reverse_postorder().length(); i++) {
     BlockEntryInstr* block = graph->reverse_postorder()[i];
     if (block->IsGraphEntry()) continue;  // No code for graph entry needed.
 
     if (block->HasParallelMove()) {
       compiler->parallel_move_resolver()->EmitNativeCode(
           block->parallel_move());
     }
 
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (FLAG_code_comments) compiler->EmitComment(instr);
       if (instr->IsParallelMove()) {
         compiler->parallel_move_resolver()->EmitNativeCode(
             instr->AsParallelMove());
+      } else if (instr->IsInvokeMathCFunction()) {
+        ASSERT(instr->locs() != NULL);
+        // InvokeMathCFunction always calls, but it uses registers that
+        // are free for the intrinsic to use.
+        instr->EmitNativeCode(compiler);
       } else {
         ASSERT(instr->locs() != NULL);
         // Calls are not supported in intrinsics code.
         ASSERT(!instr->locs()->always_calls());
         instr->EmitNativeCode(compiler);
       }
     }
   }
+  compiler->assembler()->Comment("Graph intrinsic end");
 }
 
 
 bool Intrinsifier::GraphIntrinsify(const ParsedFunction& parsed_function,
                                    FlowGraphCompiler* compiler) {
   ZoneGrowableArray<const ICData*>* ic_data_array =
       new ZoneGrowableArray<const ICData*>();
   FlowGraphBuilder builder(parsed_function,
                            *ic_data_array,
                            NULL,  // NULL = not inlining.
@@ skipping 81 matching lines @@
       return kFloat32x4Cid;
     case kUnboxedUint32:
       return kDynamicCid;  // smi or mint.
     default:
       UNREACHABLE();
       return kIllegalCid;
   }
 }
 
 
+// Notes about the graph intrinsics:
+//
+// IR instructions which would jump to a deoptimization sequence on failure
+// instead branch to the intrinsic slow path.
+//
 class BlockBuilder : public ValueObject {
  public:
   BlockBuilder(FlowGraph* flow_graph, TargetEntryInstr* entry)
       : flow_graph_(flow_graph), entry_(entry), current_(entry) { }
 
   Definition* AddToInitialDefinitions(Definition* def) {
     def->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
     flow_graph_->AddToInitialDefinitions(def);
     return def;
   }
@@ skipping 16 matching lines @@
   }
 
   Definition* AddParameter(intptr_t index) {
     intptr_t adjustment = Intrinsifier::ParameterSlotFromSp();
     return AddToInitialDefinitions(
       new ParameterInstr(adjustment + index,
                          flow_graph_->graph_entry(),
                          SPREG));
   }
 
+  Definition* AddCheckedUnbox(Representation rep, Definition* boxed) {

[Florian Schneider, 2016/03/22 16:26:21]

Remove if not needed anymore.

+    const ICData& value_check = ICData::ZoneHandle(ICData::New(
+        flow_graph_->function(),
+        String::Handle(flow_graph_->function().name()),
+        Object::empty_array(),  // Dummy args. descr.
+        Thread::kNoDeoptId,
+        1));
+    value_check.AddReceiverCheck(CidForRepresentation(rep),
+                                 flow_graph_->function());
+    AddInstruction(new CheckClassInstr(new Value(boxed),
+                                       Thread::kNoDeoptId,
+                                       value_check,
+                                       TokenPos()));
+    return AddUnboxInstr(rep, new Value(boxed), /* is_checked = */ true);
+  }
+
   TokenPosition TokenPos() {
     return flow_graph_->function().token_pos();
   }
 
   Definition* AddNullDefinition() {
     return AddDefinition(
         new ConstantInstr(Object::ZoneHandle(Object::null())));
   }
 
-  Definition* AddUnboxInstr(Representation rep, Value* value) {
+  Definition* AddUnboxInstr(Representation rep,
+                            Value* value,
+                            bool is_checked) {
     Definition* unboxed_value = AddDefinition(
         UnboxInstr::Create(rep, value, Thread::kNoDeoptId));
-    // Manually adjust reaching type because there is no type propagation
-    // when building intrinsics.
-    unboxed_value->AsUnbox()->value()->SetReachingType(ZoneCompileType::Wrap(
-        CompileType::FromCid(CidForRepresentation(rep))));
+    if (is_checked) {
+      // The type of |value| has already been checked and it is safe to
+      // adjust reaching type. This is done manually because there is no type
+      // propagation when building intrinsics.
+      unboxed_value->AsUnbox()->value()->SetReachingType(ZoneCompileType::Wrap(
+          CompileType::FromCid(CidForRepresentation(rep))));
+    }
     return unboxed_value;
   }
 
+  Definition* AddUnboxInstr(Representation rep,
+                            Definition* boxed,
+                            bool is_checked) {
+    return AddUnboxInstr(rep, new Value(boxed), is_checked);
+  }
+
+  Definition* InvokeMathCFunction(MethodRecognizer::Kind recognized_kind,
+                                  ZoneGrowableArray<Value*>* args) {
+    return InvokeMathCFunctionHelper(recognized_kind, args);
+  }
+
  private:
+  Definition* InvokeMathCFunctionHelper(MethodRecognizer::Kind recognized_kind,
+                                        ZoneGrowableArray<Value*>* args) {
+    InvokeMathCFunctionInstr* invoke_math_c_function =
+        new InvokeMathCFunctionInstr(args,
+                                     Thread::kNoDeoptId,
+                                     recognized_kind,
+                                     TokenPos());
+    AddDefinition(invoke_math_c_function);
+    return invoke_math_c_function;
+  }
+
+
   FlowGraph* flow_graph_;
   BlockEntryInstr* entry_;
   Instruction* current_;
 };
 
 
 static void PrepareIndexedOp(BlockBuilder* builder,
                              Definition* array,
                              Definition* index,
                              intptr_t length_offset) {
@@ skipping 160 matching lines @@
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* value = builder.AddParameter(1);
   Definition* index = builder.AddParameter(2);
   Definition* array = builder.AddParameter(3);
 
   PrepareIndexedOp(&builder, array, index, TypedData::length_offset());
 
   Definition* unboxed_value =
-      builder.AddUnboxInstr(kUnboxedUint32, new Value(value));
+      builder.AddUnboxInstr(kUnboxedUint32,
+                            new Value(value),
+                            /* is_checked = */ true);
 
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(array),
                             new Value(index),
                             new Value(unboxed_value),
                             kNoStoreBarrier,
                             4,  // index scale
                             kTypedDataUint32ArrayCid,
                             Thread::kNoDeoptId,
                             builder.TokenPos()));
@@ skipping 47 matching lines @@
       Object::empty_array(),  // Dummy args. descr.
       Thread::kNoDeoptId,
       1));
   value_check.AddReceiverCheck(kDoubleCid, flow_graph->function());
   builder.AddInstruction(
       new CheckClassInstr(new Value(value),
                           Thread::kNoDeoptId,
                           value_check,
                           builder.TokenPos()));
   Definition* double_value =
-      builder.AddUnboxInstr(kUnboxedDouble, new Value(value));
+      builder.AddUnboxInstr(kUnboxedDouble,
+                            new Value(value),
+                            /* is_checked = */ true);
 
   builder.AddInstruction(
       new StoreIndexedInstr(new Value(array),
                             new Value(index),
                             new Value(double_value),
                             kNoStoreBarrier,
                             8,  // index scale
                             kTypedDataFloat64ArrayCid,
                             Thread::kNoDeoptId,
                             builder.TokenPos()));
@@ skipping 47 matching lines @@
       Thread::kNoDeoptId,
       1));
   value_check.AddReceiverCheck(kFloat32x4Cid, flow_graph->function());
   // Check argument. Receiver (left) is known to be a Float32x4.
   builder.AddInstruction(
       new CheckClassInstr(new Value(right),
                           Thread::kNoDeoptId,
                           value_check,
                           builder.TokenPos()));
   Definition* left_simd =
-      builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(left));
+      builder.AddUnboxInstr(kUnboxedFloat32x4,
+                            new Value(left),
+                            /* is_checked = */ true);
 
   Definition* right_simd =
-      builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(right));
+      builder.AddUnboxInstr(kUnboxedFloat32x4,
+                            new Value(right),
+                            /* is_checked = */ true);
 
   Definition* unboxed_result = builder.AddDefinition(
       new BinaryFloat32x4OpInstr(kind,
                                  new Value(left_simd),
                                  new Value(right_simd),
                                  Thread::kNoDeoptId));
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedFloat32x4, new Value(unboxed_result)));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
@@ skipping 18 matching lines @@
 static bool BuildFloat32x4Shuffle(FlowGraph* flow_graph,
                                   MethodRecognizer::Kind kind) {
   if (!FlowGraphCompiler::SupportsUnboxedSimd128()) return false;
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* receiver = builder.AddParameter(1);
 
   Definition* unboxed_receiver =
-      builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(receiver));
+      builder.AddUnboxInstr(kUnboxedFloat32x4,
+                            new Value(receiver),
+                            /* is_checked = */ true);
 
   Definition* unboxed_result = builder.AddDefinition(
       new Simd32x4ShuffleInstr(kind,
                                new Value(unboxed_receiver),
                                0,
                                Thread::kNoDeoptId));
 
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedDouble, new Value(unboxed_result)));
   builder.AddIntrinsicReturn(new Value(result));
@@ skipping 213 matching lines @@
 }
 
 
 bool Intrinsifier::Build_DoubleFlipSignBit(FlowGraph* flow_graph) {
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
   TargetEntryInstr* normal_entry = graph_entry->normal_entry();
   BlockBuilder builder(flow_graph, normal_entry);
 
   Definition* receiver = builder.AddParameter(1);
   Definition* unboxed_value =
-      builder.AddUnboxInstr(kUnboxedDouble, new Value(receiver));
+      builder.AddUnboxInstr(kUnboxedDouble,
+                            new Value(receiver),
+                            /* is_checked = */ true);
   Definition* unboxed_result = builder.AddDefinition(
       new UnaryDoubleOpInstr(Token::kNEGATE,
                              new Value(unboxed_value),
                              Thread::kNoDeoptId));
   Definition* result = builder.AddDefinition(
       BoxInstr::Create(kUnboxedDouble, new Value(unboxed_result)));
   builder.AddIntrinsicReturn(new Value(result));
   return true;
 }
 
+
+static bool BuildInvokeMathCFunction(BlockBuilder* builder,
+                                     MethodRecognizer::Kind kind,
+                                     intptr_t num_parameters = 1) {
+  ZoneGrowableArray<Value*>* args =
+      new ZoneGrowableArray<Value*>(num_parameters);
+
+  for (intptr_t i = 0; i < num_parameters; i++) {
+    const intptr_t parameter_index = (num_parameters - i);
+    Definition* value = builder->AddParameter(parameter_index);
+    Definition* unboxed_value =
+        builder->AddUnboxInstr(kUnboxedDouble, value, /* is_checked = */ false);
+    args->Add(new Value(unboxed_value));
+  }
+
+  Definition* unboxed_result =
+      builder->InvokeMathCFunction(kind, args);
+
+  Definition* result = builder->AddDefinition(
+      BoxInstr::Create(kUnboxedDouble, new Value(unboxed_result)));
+
+  builder->AddIntrinsicReturn(new Value(result));
+
+  return true;
+}
+
+
+bool Intrinsifier::Build_MathSin(FlowGraph* flow_graph) {
+  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  return BuildInvokeMathCFunction(&builder,
+                                  MethodRecognizer::kMathSin);
+}
+
+
+bool Intrinsifier::Build_MathCos(FlowGraph* flow_graph) {
+  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  return BuildInvokeMathCFunction(&builder,
+                                  MethodRecognizer::kMathCos);
+}
+
+
+bool Intrinsifier::Build_MathTan(FlowGraph* flow_graph) {
+  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  return BuildInvokeMathCFunction(&builder,
+                                  MethodRecognizer::kMathTan);
+}
+
+
+bool Intrinsifier::Build_MathAsin(FlowGraph* flow_graph) {
+  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  return BuildInvokeMathCFunction(&builder,
+                                  MethodRecognizer::kMathAsin);
+}
+
+
+bool Intrinsifier::Build_MathAcos(FlowGraph* flow_graph) {
+  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  return BuildInvokeMathCFunction(&builder,
+                                  MethodRecognizer::kMathAcos);
+}
+
+
+bool Intrinsifier::Build_MathAtan(FlowGraph* flow_graph) {
+  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  return BuildInvokeMathCFunction(&builder,
+                                  MethodRecognizer::kMathAtan);
+}
+
+
+bool Intrinsifier::Build_MathAtan2(FlowGraph* flow_graph) {
+  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  TargetEntryInstr* normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
+  return BuildInvokeMathCFunction(&builder,
+                                  MethodRecognizer::kMathAtan2,
+                                  /* num_parameters = */ 2);
+}
+
 }  // namespace dart