diff --git a/runtime/vm/compiler/asm_intrinsifier.h b/runtime/vm/compiler/asm_intrinsifier.h
index 4745bad..9d3f04b 100644
--- a/runtime/vm/compiler/asm_intrinsifier.h
+++ b/runtime/vm/compiler/asm_intrinsifier.h
@@ -31,9 +31,6 @@
  public:
   static intptr_t ParameterSlotFromSp();
 
-  static void IntrinsicCallPrologue(Assembler* assembler);
-  static void IntrinsicCallEpilogue(Assembler* assembler);
-
  private:
   friend class Intrinsifier;
 
diff --git a/runtime/vm/compiler/asm_intrinsifier_arm.cc b/runtime/vm/compiler/asm_intrinsifier_arm.cc
index e7f2ee1..454fb02 100644
--- a/runtime/vm/compiler/asm_intrinsifier_arm.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_arm.cc
@@ -28,24 +28,6 @@
   return -1;
 }
 
-void AsmIntrinsifier::IntrinsicCallPrologue(Assembler* assembler) {
-  COMPILE_ASSERT(IsAbiPreservedRegister(CODE_REG));
-  COMPILE_ASSERT(IsAbiPreservedRegister(ARGS_DESC_REG));
-  COMPILE_ASSERT(IsAbiPreservedRegister(CALLEE_SAVED_TEMP));
-
-  // Save LR by moving it to a callee saved temporary register.
-  __ Comment("IntrinsicCallPrologue");
-  SPILLS_RETURN_ADDRESS_FROM_LR_TO_REGISTER(
-      __ mov(CALLEE_SAVED_TEMP, Operand(LR)));
-}
-
-void AsmIntrinsifier::IntrinsicCallEpilogue(Assembler* assembler) {
-  // Restore LR.
-  __ Comment("IntrinsicCallEpilogue");
-  RESTORES_RETURN_ADDRESS_FROM_REGISTER_TO_LR(
-      __ mov(LR, Operand(CALLEE_SAVED_TEMP)));
-}
-
 // Allocate a GrowableObjectArray:: using the backing array specified.
 // On stack: type argument (+1), data (+0).
 void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
diff --git a/runtime/vm/compiler/asm_intrinsifier_arm64.cc b/runtime/vm/compiler/asm_intrinsifier_arm64.cc
index 1e0134a..03d3818 100644
--- a/runtime/vm/compiler/asm_intrinsifier_arm64.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_arm64.cc
@@ -28,27 +28,6 @@
   return -1;
 }
 
-void AsmIntrinsifier::IntrinsicCallPrologue(Assembler* assembler) {
-  COMPILE_ASSERT(IsAbiPreservedRegister(CODE_REG));
-  COMPILE_ASSERT(!IsAbiPreservedRegister(ARGS_DESC_REG));
-  COMPILE_ASSERT(IsAbiPreservedRegister(CALLEE_SAVED_TEMP));
-  COMPILE_ASSERT(IsAbiPreservedRegister(CALLEE_SAVED_TEMP2));
-  COMPILE_ASSERT(CALLEE_SAVED_TEMP != CODE_REG);
-  COMPILE_ASSERT(CALLEE_SAVED_TEMP != ARGS_DESC_REG);
-  COMPILE_ASSERT(CALLEE_SAVED_TEMP2 != CODE_REG);
-  COMPILE_ASSERT(CALLEE_SAVED_TEMP2 != ARGS_DESC_REG);
-
-  __ Comment("IntrinsicCallPrologue");
-  SPILLS_RETURN_ADDRESS_FROM_LR_TO_REGISTER(__ mov(CALLEE_SAVED_TEMP, LR));
-  __ mov(CALLEE_SAVED_TEMP2, ARGS_DESC_REG);
-}
-
-void AsmIntrinsifier::IntrinsicCallEpilogue(Assembler* assembler) {
-  __ Comment("IntrinsicCallEpilogue");
-  RESTORES_RETURN_ADDRESS_FROM_REGISTER_TO_LR(__ mov(LR, CALLEE_SAVED_TEMP));
-  __ mov(ARGS_DESC_REG, CALLEE_SAVED_TEMP2);
-}
-
 // Allocate a GrowableObjectArray:: using the backing array specified.
 // On stack: type argument (+1), data (+0).
 void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
diff --git a/runtime/vm/compiler/asm_intrinsifier_ia32.cc b/runtime/vm/compiler/asm_intrinsifier_ia32.cc
index a6f1c9d..9c52f2a 100644
--- a/runtime/vm/compiler/asm_intrinsifier_ia32.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_ia32.cc
@@ -35,18 +35,6 @@
   return 0;
 }
 
-void AsmIntrinsifier::IntrinsicCallPrologue(Assembler* assembler) {
-  COMPILE_ASSERT(CALLEE_SAVED_TEMP != ARGS_DESC_REG);
-
-  assembler->Comment("IntrinsicCallPrologue");
-  assembler->movl(CALLEE_SAVED_TEMP, ARGS_DESC_REG);
-}
-
-void AsmIntrinsifier::IntrinsicCallEpilogue(Assembler* assembler) {
-  assembler->Comment("IntrinsicCallEpilogue");
-  assembler->movl(ARGS_DESC_REG, CALLEE_SAVED_TEMP);
-}
-
 // Allocate a GrowableObjectArray:: using the backing array specified.
 // On stack: type argument (+2), data (+1), return-address (+0).
 void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
diff --git a/runtime/vm/compiler/asm_intrinsifier_x64.cc b/runtime/vm/compiler/asm_intrinsifier_x64.cc
index 3196c49..131a261 100644
--- a/runtime/vm/compiler/asm_intrinsifier_x64.cc
+++ b/runtime/vm/compiler/asm_intrinsifier_x64.cc
@@ -28,22 +28,6 @@
   return 0;
 }
 
-void AsmIntrinsifier::IntrinsicCallPrologue(Assembler* assembler) {
-  COMPILE_ASSERT(IsAbiPreservedRegister(CODE_REG));
-  COMPILE_ASSERT(!IsAbiPreservedRegister(ARGS_DESC_REG));
-  COMPILE_ASSERT(IsAbiPreservedRegister(CALLEE_SAVED_TEMP));
-  COMPILE_ASSERT(CALLEE_SAVED_TEMP != CODE_REG);
-  COMPILE_ASSERT(CALLEE_SAVED_TEMP != ARGS_DESC_REG);
-
-  assembler->Comment("IntrinsicCallPrologue");
-  assembler->movq(CALLEE_SAVED_TEMP, ARGS_DESC_REG);
-}
-
-void AsmIntrinsifier::IntrinsicCallEpilogue(Assembler* assembler) {
-  assembler->Comment("IntrinsicCallEpilogue");
-  assembler->movq(ARGS_DESC_REG, CALLEE_SAVED_TEMP);
-}
-
 // Allocate a GrowableObjectArray using the backing array specified.
 // On stack: type argument (+2), data (+1), return-address (+0).
 void AsmIntrinsifier::GrowableArray_Allocate(Assembler* assembler,
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index 28f499c..c7973a2 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -6178,10 +6178,7 @@
   switch (kind) {
     case MethodRecognizer::kDoubleTruncate:
     case MethodRecognizer::kDoubleFloor:
-    case MethodRecognizer::kDoubleCeil: {
-      ASSERT(!TargetCPUFeatures::double_truncate_round_supported());
-      return 1;
-    }
+    case MethodRecognizer::kDoubleCeil:
     case MethodRecognizer::kDoubleRound:
     case MethodRecognizer::kMathAtan:
     case MethodRecognizer::kMathTan:
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index 911426b..d8b607c 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -8394,6 +8394,11 @@
     return kUnboxedDouble;
   }
 
+  virtual SpeculativeMode SpeculativeModeOfInput(intptr_t idx) const {
+    ASSERT(idx == 0);
+    return kNotSpeculative;
+  }
+
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual bool AttributesEqual(const Instruction& other) const {
@@ -8512,6 +8517,11 @@
     return kUnboxedDouble;
   }
 
+  virtual SpeculativeMode SpeculativeModeOfInput(intptr_t idx) const {
+    ASSERT((0 <= idx) && (idx < InputCount()));
+    return kNotSpeculative;
+  }
+
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual intptr_t InputCount() const { return inputs_->length(); }
diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index 944673b..c87f165 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc
@@ -5344,30 +5344,36 @@
                                                                bool opt) const {
   // Calling convention on x64 uses XMM0 and XMM1 to pass the first two
   // double arguments and XMM0 to return the result.
-  //
-  // TODO(sjindel): allow XMM0 to be used. Requires refactoring InvokeDoublePow
-  // to allow input 1/output register to be equal.
-  ASSERT((InputCount() == 1) || (InputCount() == 2));
-  const intptr_t kNumTemps =
-      (recognized_kind() == MethodRecognizer::kMathDoublePow) ? 4 : 1;
-  LocationSummary* result = new (zone)
-      LocationSummary(zone, InputCount(), kNumTemps, LocationSummary::kCall);
   ASSERT(R13 != CALLEE_SAVED_TEMP);
   ASSERT(((1 << R13) & CallingConventions::kCalleeSaveCpuRegisters) != 0);
-  result->set_temp(0, Location::RegisterLocation(R13));
-  result->set_in(0, Location::FpuRegisterLocation(XMM2));
-  if (InputCount() == 2) {
-    result->set_in(1, Location::FpuRegisterLocation(XMM1));
-  }
+
   if (recognized_kind() == MethodRecognizer::kMathDoublePow) {
+    ASSERT(InputCount() == 2);
+    const intptr_t kNumTemps = 4;
+    LocationSummary* result = new (zone)
+        LocationSummary(zone, InputCount(), kNumTemps, LocationSummary::kCall);
+    result->set_in(0, Location::FpuRegisterLocation(XMM2));
+    result->set_in(1, Location::FpuRegisterLocation(XMM1));
+    result->set_temp(0, Location::RegisterLocation(R13));
     // Temp index 1.
     result->set_temp(1, Location::RegisterLocation(RAX));
     // Temp index 2.
     result->set_temp(2, Location::FpuRegisterLocation(XMM4));
     // Block XMM0 for the calling convention.
     result->set_temp(3, Location::FpuRegisterLocation(XMM0));
+    result->set_out(0, Location::FpuRegisterLocation(XMM3));
+    return result;
   }
-  result->set_out(0, Location::FpuRegisterLocation(XMM3));
+  ASSERT((InputCount() == 1) || (InputCount() == 2));
+  const intptr_t kNumTemps = 1;
+  LocationSummary* result = new (zone)
+      LocationSummary(zone, InputCount(), kNumTemps, LocationSummary::kCall);
+  result->set_temp(0, Location::RegisterLocation(R13));
+  result->set_in(0, Location::FpuRegisterLocation(XMM0));
+  if (InputCount() == 2) {
+    result->set_in(1, Location::FpuRegisterLocation(XMM1));
+  }
+  result->set_out(0, Location::FpuRegisterLocation(XMM0));
   return result;
 }
 
@@ -5509,17 +5515,20 @@
     InvokeDoublePow(compiler, this);
     return;
   }
-  // Save RSP.
-  __ movq(locs()->temp(kSavedSpTempIndex).reg(), RSP);
-  __ ReserveAlignedFrameSpace(0);
-  __ movaps(XMM0, locs()->in(0).fpu_reg());
+
+  ASSERT(locs()->in(0).fpu_reg() == XMM0);
   if (InputCount() == 2) {
     ASSERT(locs()->in(1).fpu_reg() == XMM1);
   }
 
+  // Save RSP.
+  __ movq(locs()->temp(kSavedSpTempIndex).reg(), RSP);
+  __ ReserveAlignedFrameSpace(0);
+
   ASSERT(TargetFunction().is_leaf());  // No deopt info needed.
   __ CallRuntime(TargetFunction(), InputCount());
-  __ movaps(locs()->out(0).fpu_reg(), XMM0);
+  ASSERT(locs()->out(0).fpu_reg() == XMM0);
+
   // Restore RSP.
   __ movq(RSP, locs()->temp(kSavedSpTempIndex).reg());
 }
diff --git a/runtime/vm/compiler/call_specializer.cc b/runtime/vm/compiler/call_specializer.cc
index d386935..61e2f54 100644
--- a/runtime/vm/compiler/call_specializer.cc
+++ b/runtime/vm/compiler/call_specializer.cc
@@ -968,21 +968,6 @@
   return TryInlineImplicitInstanceGetter(call);
 }
 
-void CallSpecializer::ReplaceWithMathCFunction(
-    InstanceCallInstr* call,
-    MethodRecognizer::Kind recognized_kind) {
-  ASSERT(call->type_args_len() == 0);
-  AddReceiverCheck(call);
-  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)));
-  }
-  InvokeMathCFunctionInstr* invoke = new (Z) InvokeMathCFunctionInstr(
-      args, call->deopt_id(), recognized_kind, call->source());
-  ReplaceCall(call, invoke);
-}
-
 // Inline only simple, frequently called core library methods.
 bool CallSpecializer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   const CallTargets& targets = call->Targets();
@@ -1034,23 +1019,6 @@
         ReplaceCall(call, d2i_instr);
         return true;
       }
-      case MethodRecognizer::kDoubleMod:
-      case MethodRecognizer::kDoubleRound:
-        ReplaceWithMathCFunction(call, recognized_kind);
-        return true;
-      case MethodRecognizer::kDoubleTruncate:
-      case MethodRecognizer::kDoubleFloor:
-      case MethodRecognizer::kDoubleCeil:
-        if (!TargetCPUFeatures::double_truncate_round_supported()) {
-          ReplaceWithMathCFunction(call, recognized_kind);
-        } else {
-          AddReceiverCheck(call);
-          DoubleToDoubleInstr* d2d_instr =
-              new (Z) DoubleToDoubleInstr(new (Z) Value(call->ArgumentAt(0)),
-                                          recognized_kind, call->deopt_id());
-          ReplaceCall(call, d2d_instr);
-        }
-        return true;
       default:
         break;
     }
diff --git a/runtime/vm/compiler/call_specializer.h b/runtime/vm/compiler/call_specializer.h
index e82a69c..7e84402 100644
--- a/runtime/vm/compiler/call_specializer.h
+++ b/runtime/vm/compiler/call_specializer.h
@@ -172,9 +172,6 @@
   bool TryOptimizeInstanceOfUsingStaticTypes(InstanceCallInstr* call,
                                              const AbstractType& type);
 
-  void ReplaceWithMathCFunction(InstanceCallInstr* call,
-                                MethodRecognizer::Kind recognized_kind);
-
   bool TryStringLengthOneEquality(InstanceCallInstr* call, Token::Kind op_kind);
 
   void SpecializePolymorphicInstanceCall(PolymorphicInstanceCallInstr* call);
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
index 4c3a5cf..4e16bfe 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
@@ -1193,5 +1193,25 @@
   return instructions;
 }
 
+Fragment BaseFlowGraphBuilder::InvokeMathCFunction(
+    MethodRecognizer::Kind recognized_kind,
+    intptr_t num_inputs) {
+  InputsArray* args = GetArguments(num_inputs);
+  auto* instr = new (Z)
+      InvokeMathCFunctionInstr(args, GetNextDeoptId(), recognized_kind,
+                               InstructionSource(TokenPosition::kNoSource));
+  Push(instr);
+  return Fragment(instr);
+}
+
+Fragment BaseFlowGraphBuilder::DoubleToDouble(
+    MethodRecognizer::Kind recognized_kind) {
+  Value* value = Pop();
+  auto* instr =
+      new (Z) DoubleToDoubleInstr(value, recognized_kind, GetNextDeoptId());
+  Push(instr);
+  return Fragment(instr);
+}
+
 }  // namespace kernel
 }  // namespace dart
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.h b/runtime/vm/compiler/frontend/base_flow_graph_builder.h
index edad1e4..f3ef8e0 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.h
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.h
@@ -436,6 +436,14 @@
   // Sets raw parameter variables to inferred constant values.
   Fragment InitConstantParameters();
 
+  Fragment InvokeMathCFunction(MethodRecognizer::Kind recognized_kind,
+                               intptr_t num_inputs);
+
+  // Pops double value and converts it to double as specified
+  // by the recognized method (kDoubleTruncate,
+  // kDoubleFloor or kDoubleCeil).
+  Fragment DoubleToDouble(MethodRecognizer::Kind recognized_kind);
+
   // Returns whether this function has a saved arguments descriptor array.
   bool has_saved_args_desc_array() {
     return function_.HasSavedArgumentsDescriptor();
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index 2054bbb..870c86f 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -988,7 +988,7 @@
     case UntaggedFunction::kSetterFunction:
     case UntaggedFunction::kClosureFunction:
     case UntaggedFunction::kConstructor: {
-      if (B->IsRecognizedMethodForFlowGraph(function)) {
+      if (FlowGraphBuilder::IsRecognizedMethodForFlowGraph(function)) {
         return B->BuildGraphOfRecognizedMethod(function);
       }
       return BuildGraphOfFunction(function.IsGenerativeConstructor());
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 0930d3d..2e2f061 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -8,6 +8,7 @@
 #include "platform/globals.h"
 #include "vm/class_id.h"
 #include "vm/compiler/aot/precompiler.h"
+#include "vm/compiler/backend/flow_graph_compiler.h"
 #include "vm/compiler/backend/il.h"
 #include "vm/compiler/backend/il_printer.h"
 #include "vm/compiler/backend/locations.h"
@@ -891,6 +892,12 @@
     case MethodRecognizer::kUtf8DecoderScan:
     case MethodRecognizer::kHas63BitSmis:
       return true;
+    case MethodRecognizer::kDoubleMod:
+    case MethodRecognizer::kDoubleRound:
+    case MethodRecognizer::kDoubleTruncate:
+    case MethodRecognizer::kDoubleFloor:
+    case MethodRecognizer::kDoubleCeil:
+      return FlowGraphCompiler::SupportsUnboxedDoubles();
     default:
       return false;
   }
@@ -1506,6 +1513,24 @@
       body += LoadIndexed(kIntPtrCid);
       body += Box(kUnboxedIntPtr);
     } break;
+    case MethodRecognizer::kDoubleMod:
+    case MethodRecognizer::kDoubleRound:
+    case MethodRecognizer::kDoubleTruncate:
+    case MethodRecognizer::kDoubleFloor:
+    case MethodRecognizer::kDoubleCeil: {
+      for (intptr_t i = 0, n = function.NumParameters(); i < n; ++i) {
+        body += LoadLocal(parsed_function_->RawParameterVariable(i));
+      }
+      if (!CompilerState::Current().is_aot() &&
+          TargetCPUFeatures::double_truncate_round_supported() &&
+          ((kind == MethodRecognizer::kDoubleTruncate) ||
+           (kind == MethodRecognizer::kDoubleFloor) ||
+           (kind == MethodRecognizer::kDoubleCeil))) {
+        body += DoubleToDouble(kind);
+      } else {
+        body += InvokeMathCFunction(kind, function.NumParameters());
+      }
+    } break;
     default: {
       UNREACHABLE();
       break;
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.h b/runtime/vm/compiler/frontend/kernel_to_il.h
index f9d1a6e..20c5b77c 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.h
+++ b/runtime/vm/compiler/frontend/kernel_to_il.h
@@ -65,6 +65,10 @@
 
   FlowGraph* BuildGraph();
 
+  // Returns true if given [function] is recognized for flow
+  // graph building and its body is expressed in a custom-built IL.
+  static bool IsRecognizedMethodForFlowGraph(const Function& function);
+
  private:
   BlockEntryInstr* BuildPrologue(BlockEntryInstr* normal_entry,
                                  PrologueInfo* prologue_info);
@@ -145,8 +149,6 @@
   Fragment NativeFunctionBody(const Function& function,
                               LocalVariable* first_parameter);
 
-  // Every recognized method has a body expressed in IL.
-  bool IsRecognizedMethodForFlowGraph(const Function& function);
   FlowGraph* BuildGraphOfRecognizedMethod(const Function& function);
 
   Fragment BuildTypedDataViewFactoryConstructor(const Function& function,
diff --git a/runtime/vm/compiler/graph_intrinsifier.cc b/runtime/vm/compiler/graph_intrinsifier.cc
index 49287d4..a97c2fb 100644
--- a/runtime/vm/compiler/graph_intrinsifier.cc
+++ b/runtime/vm/compiler/graph_intrinsifier.cc
@@ -1121,40 +1121,6 @@
   return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathLog);
 }
 
-bool GraphIntrinsifier::Build_DoubleMod(FlowGraph* flow_graph) {
-  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleMod,
-                                  /* num_parameters = */ 2);
-}
-
-bool GraphIntrinsifier::Build_DoubleCeil(FlowGraph* flow_graph) {
-  // TODO(johnmccutchan): On X86 this intrinsic can be written in a different
-  // way.
-  if (TargetCPUFeatures::double_truncate_round_supported()) return false;
-
-  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleCeil);
-}
-
-bool GraphIntrinsifier::Build_DoubleFloor(FlowGraph* flow_graph) {
-  // TODO(johnmccutchan): On X86 this intrinsic can be written in a different
-  // way.
-  if (TargetCPUFeatures::double_truncate_round_supported()) return false;
-
-  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleFloor);
-}
-
-bool GraphIntrinsifier::Build_DoubleTruncate(FlowGraph* flow_graph) {
-  // TODO(johnmccutchan): On X86 this intrinsic can be written in a different
-  // way.
-  if (TargetCPUFeatures::double_truncate_round_supported()) return false;
-
-  return BuildInvokeMathCFunction(flow_graph,
-                                  MethodRecognizer::kDoubleTruncate);
-}
-
-bool GraphIntrinsifier::Build_DoubleRound(FlowGraph* flow_graph) {
-  return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleRound);
-}
-
 bool GraphIntrinsifier::Build_ImplicitGetter(FlowGraph* flow_graph) {
   // This code will only be invoked if our assumptions have been met (see
   // [Intrinsifier::CanIntrinsifyFieldAccessor])
diff --git a/runtime/vm/compiler/recognized_methods_list.h b/runtime/vm/compiler/recognized_methods_list.h
index 9680f0b..8bf5cf9 100644
--- a/runtime/vm/compiler/recognized_methods_list.h
+++ b/runtime/vm/compiler/recognized_methods_list.h
@@ -87,6 +87,11 @@
   V(_Double, _sub, DoubleSub, 0x28474c2e)                                      \
   V(_Double, _mul, DoubleMul, 0x1f98c76c)                                      \
   V(_Double, _div, DoubleDiv, 0x287d3791)                                      \
+  V(_Double, _modulo, DoubleMod, 0xfdb397ef)                                   \
+  V(_Double, ceilToDouble, DoubleCeil, 0x5f1bced9)                             \
+  V(_Double, floorToDouble, DoubleFloor, 0x54b4cb48)                           \
+  V(_Double, roundToDouble, DoubleRound, 0x5649ca00)                           \
+  V(_Double, truncateToDouble, DoubleTruncate, 0x62d48659)                     \
   V(::, min, MathMin, 0x504a28df)                                              \
   V(::, max, MathMax, 0xead7161a)                                              \
   V(::, _doublePow, MathDoublePow, 0x989f3334)                                 \
@@ -366,11 +371,6 @@
   V(_IntegerImplementation, >>, Integer_sar, 0x4a3615a7)                       \
   V(_IntegerImplementation, >>>, Integer_shr, 0x2bac5209)                      \
   V(_Double, unary-, DoubleFlipSignBit, 0x3d39082b)                            \
-  V(_Double, truncateToDouble, DoubleTruncate, 0x62d48298)                     \
-  V(_Double, roundToDouble, DoubleRound, 0x5649c63f)                           \
-  V(_Double, floorToDouble, DoubleFloor, 0x54b4c787)                           \
-  V(_Double, ceilToDouble, DoubleCeil, 0x5f1bcb18)                             \
-  V(_Double, _modulo, DoubleMod, 0xfdb3942e)
 
 #define GRAPH_INTRINSICS_LIST(V)                                               \
   GRAPH_CORE_INTRINSICS_LIST(V)                                                \
diff --git a/sdk/lib/_internal/vm/lib/double.dart b/sdk/lib/_internal/vm/lib/double.dart
index ab3b88d..e1dca3d 100644
--- a/sdk/lib/_internal/vm/lib/double.dart
+++ b/sdk/lib/_internal/vm/lib/double.dart
@@ -67,7 +67,8 @@
     return _modulo(other.toDouble());
   }
 
-  @pragma("vm:recognized", "graph-intrinsic")
+  @pragma("vm:recognized", "other")
+  @pragma("vm:prefer-inline")
   @pragma("vm:exact-result-type", _Double)
   double _modulo(double other) native "Double_modulo";
 
@@ -181,16 +182,20 @@
   int ceil() => ceilToDouble().toInt();
   int truncate() => truncateToDouble().toInt();
 
-  @pragma("vm:recognized", "graph-intrinsic")
+  @pragma("vm:recognized", "other")
+  @pragma("vm:prefer-inline")
   @pragma("vm:exact-result-type", _Double)
   double roundToDouble() native "Double_round";
-  @pragma("vm:recognized", "graph-intrinsic")
+  @pragma("vm:recognized", "other")
+  @pragma("vm:prefer-inline")
   @pragma("vm:exact-result-type", _Double)
   double floorToDouble() native "Double_floor";
-  @pragma("vm:recognized", "graph-intrinsic")
+  @pragma("vm:recognized", "other")
+  @pragma("vm:prefer-inline")
   @pragma("vm:exact-result-type", _Double)
   double ceilToDouble() native "Double_ceil";
-  @pragma("vm:recognized", "graph-intrinsic")
+  @pragma("vm:recognized", "other")
+  @pragma("vm:prefer-inline")
   @pragma("vm:exact-result-type", _Double)
   double truncateToDouble() native "Double_truncate";