[vm, compiler] Use leaf calls for exp and log.

We already do this for the other functions in dart:math.

TEST=ci
Bug: #45414
Change-Id: Ic1fb1c7cdbbf39eaa4af645219874408988b740b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/192522
Commit-Queue: Ryan Macnak <[email protected]>
Reviewed-by: Vyacheslav Egorov <[email protected]>

Author: rmacnak-google

runtime/vm/compiler/backend/il.cc

@@ -6202,6 +6202,8 @@ intptr_t InvokeMathCFunctionInstr::ArgumentCountFor(
     case MethodRecognizer::kMathAsin:
     case MethodRecognizer::kMathSin:
     case MethodRecognizer::kMathCos:
+    case MethodRecognizer::kMathExp:
+    case MethodRecognizer::kMathLog:
       return 1;
     case MethodRecognizer::kDoubleMod:
     case MethodRecognizer::kMathDoublePow:
@@ -6241,6 +6243,10 @@ const RuntimeEntry& InvokeMathCFunctionInstr::TargetFunction() const {
       return kLibcAtanRuntimeEntry;
     case MethodRecognizer::kMathAtan2:
       return kLibcAtan2RuntimeEntry;
+    case MethodRecognizer::kMathExp:
+      return kLibcExpRuntimeEntry;
+    case MethodRecognizer::kMathLog:
+      return kLibcLogRuntimeEntry;
     default:
       UNREACHABLE();
   }

runtime/vm/compiler/backend/inliner.cc

@@ -3985,6 +3985,8 @@ bool FlowGraphInliner::TryInlineRecognizedMethod(
     case MethodRecognizer::kMathAcos:
     case MethodRecognizer::kMathAtan:
     case MethodRecognizer::kMathAtan2:
+    case MethodRecognizer::kMathExp:
+    case MethodRecognizer::kMathLog:
       return InlineMathCFunction(flow_graph, call, kind, graph_entry, entry,
                                  last, result);
 

runtime/vm/compiler/graph_intrinsifier.cc

@@ -962,177 +962,109 @@ bool GraphIntrinsifier::Build_DoubleFlipSignBit(FlowGraph* flow_graph) {
   return true;
 }
 
-static bool BuildInvokeMathCFunction(BlockBuilder* builder,
+static bool BuildInvokeMathCFunction(FlowGraph* flow_graph,
                                      MethodRecognizer::Kind kind,
-                                     FlowGraph* flow_graph,
                                      intptr_t num_parameters = 1) {
   if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
     return false;
   }
+
+  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
+  auto normal_entry = graph_entry->normal_entry();
+  BlockBuilder builder(flow_graph, normal_entry);
+
   ZoneGrowableArray<Value*>* args =
       new ZoneGrowableArray<Value*>(num_parameters);
 
   for (intptr_t i = 0; i < num_parameters; i++) {
-    Definition* value = builder->AddParameter(i, /*with_frame=*/false);
+    Definition* value = builder.AddParameter(i, /*with_frame=*/false);
     Definition* unboxed_value = ConvertOrUnboxDoubleParameter(
-        builder, value, i, /* is_checked = */ false);
+        &builder, value, i, /* is_checked = */ false);
     if (unboxed_value == nullptr) {
       return false;
     }
     args->Add(new Value(unboxed_value));
   }
 
   Definition* unboxed_result =
-      builder->AddDefinition(new InvokeMathCFunctionInstr(
-          args, DeoptId::kNone, kind, builder->Source()));
+      builder.AddDefinition(new InvokeMathCFunctionInstr(
+          args, DeoptId::kNone, kind, builder.Source()));
   Definition* result =
-      CreateBoxedResultIfNeeded(builder, unboxed_result, kUnboxedDouble);
-  builder->AddReturn(new Value(result));
+      CreateBoxedResultIfNeeded(&builder, unboxed_result, kUnboxedDouble);
+  builder.AddReturn(new Value(result));
 
   return true;
 }
 
 bool GraphIntrinsifier::Build_MathSin(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kMathSin,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathSin);
 }
 
 bool GraphIntrinsifier::Build_MathCos(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kMathCos,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathCos);
 }
 
 bool GraphIntrinsifier::Build_MathTan(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kMathTan,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathTan);
 }
 
 bool GraphIntrinsifier::Build_MathAsin(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kMathAsin,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAsin);
 }
 
 bool GraphIntrinsifier::Build_MathAcos(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kMathAcos,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAcos);
 }
 
 bool GraphIntrinsifier::Build_MathAtan(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kMathAtan,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAtan);
 }
 
 bool GraphIntrinsifier::Build_MathAtan2(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kMathAtan2,
-                                  flow_graph,
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAtan2,
                                   /* num_parameters = */ 2);
 }
 
-bool GraphIntrinsifier::Build_DoubleMod(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
+bool GraphIntrinsifier::Build_MathExp(FlowGraph* flow_graph) {
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathExp);
+}
 
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
+bool GraphIntrinsifier::Build_MathLog(FlowGraph* flow_graph) {
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathLog);
+}
 
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kDoubleMod,
-                                  flow_graph,
+bool GraphIntrinsifier::Build_DoubleMod(FlowGraph* flow_graph) {
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleMod,
                                   /* num_parameters = */ 2);
 }
 
 bool GraphIntrinsifier::Build_DoubleCeil(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
   // TODO(johnmccutchan): On X86 this intrinsic can be written in a different
   // way.
   if (TargetCPUFeatures::double_truncate_round_supported()) return false;
 
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kDoubleCeil,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleCeil);
 }
 
 bool GraphIntrinsifier::Build_DoubleFloor(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
   // TODO(johnmccutchan): On X86 this intrinsic can be written in a different
   // way.
   if (TargetCPUFeatures::double_truncate_round_supported()) return false;
 
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kDoubleFloor,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleFloor);
 }
 
 bool GraphIntrinsifier::Build_DoubleTruncate(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
   // TODO(johnmccutchan): On X86 this intrinsic can be written in a different
   // way.
   if (TargetCPUFeatures::double_truncate_round_supported()) return false;
 
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kDoubleTruncate,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph,
+                                  MethodRecognizer::kDoubleTruncate);
 }
 
 bool GraphIntrinsifier::Build_DoubleRound(FlowGraph* flow_graph) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
-
-  GraphEntryInstr* graph_entry = flow_graph->graph_entry();
-  auto normal_entry = graph_entry->normal_entry();
-  BlockBuilder builder(flow_graph, normal_entry);
-
-  return BuildInvokeMathCFunction(&builder, MethodRecognizer::kDoubleRound,
-                                  flow_graph);
+  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleRound);
 }
 
 bool GraphIntrinsifier::Build_ImplicitGetter(FlowGraph* flow_graph) {

runtime/vm/compiler/recognized_methods_list.h

@@ -289,6 +289,8 @@ namespace dart {
   V(::, acos, MathAcos, 0xffb03167)                                            \
   V(::, atan, MathAtan, 0xf1ecb41a)                                            \
   V(::, atan2, MathAtan2, 0xff585505)                                          \
+  V(::, exp, MathExp, 0xbb87ac43)                                              \
+  V(::, log, MathLog, 0x27ec861f)                                              \
 
 #define GRAPH_TYPED_DATA_INTRINSICS_LIST(V)                                    \
   V(_Int8List, [], Int8ArrayGetIndexed, 0x281e2e42)                            \