diff --git a/runtime/vm/compiler/aot/aot_call_specializer.cc b/runtime/vm/compiler/aot/aot_call_specializer.cc
index 346fd28ba30..6453c19cb7d 100644
--- a/runtime/vm/compiler/aot/aot_call_specializer.cc
+++ b/runtime/vm/compiler/aot/aot_call_specializer.cc
@@ -651,10 +651,6 @@ bool AotCallSpecializer::TryOptimizeDoubleOperation(TemplateDartCall<0>* instr,
     return false;
   }
 
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
-    return false;
-  }
-
   Definition* replacement = nullptr;
 
   if (instr->ArgumentCount() == 2) {
diff --git a/runtime/vm/compiler/backend/constant_propagator.cc b/runtime/vm/compiler/backend/constant_propagator.cc
index 405cbeee053..f1c80aa103d 100644
--- a/runtime/vm/compiler/backend/constant_propagator.cc
+++ b/runtime/vm/compiler/backend/constant_propagator.cc
@@ -916,8 +916,7 @@ void ConstantPropagator::VisitInstanceOf(InstanceOfInstr* instr) {
     Representation rep = def->representation();
     if ((checked_type.IsFloat32x4Type() && (rep == kUnboxedFloat32x4)) ||
         (checked_type.IsInt32x4Type() && (rep == kUnboxedInt32x4)) ||
-        (checked_type.IsDoubleType() && (rep == kUnboxedDouble) &&
-         FlowGraphCompiler::SupportsUnboxedDoubles()) ||
+        (checked_type.IsDoubleType() && (rep == kUnboxedDouble)) ||
         (checked_type.IsIntType() && (rep == kUnboxedInt64))) {
       // Ensure that compile time type matches representation.
       ASSERT(((rep == kUnboxedFloat32x4) && (value_cid == kFloat32x4Cid)) ||
diff --git a/runtime/vm/compiler/backend/flow_graph.cc b/runtime/vm/compiler/backend/flow_graph.cc
index c700eab7961..618cf8250ca 100644
--- a/runtime/vm/compiler/backend/flow_graph.cc
+++ b/runtime/vm/compiler/backend/flow_graph.cc
@@ -1930,10 +1930,6 @@ static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
-static bool CanUnboxDouble() {
-  return FlowGraphCompiler::SupportsUnboxedDoubles();
-}
-
 static bool CanConvertInt64ToDouble() {
   return FlowGraphCompiler::CanConvertInt64ToDouble();
 }
@@ -1975,7 +1971,6 @@ void FlowGraph::InsertConversion(Representation from,
     const intptr_t deopt_id = (deopt_target != nullptr)
                                   ? deopt_target->DeoptimizationTarget()
                                   : DeoptId::kNone;
-    ASSERT(CanUnboxDouble());
     converted = new Int64ToDoubleInstr(use->CopyWithType(), deopt_id);
   } else if ((from == kTagged) && Boxing::Supports(to)) {
     const intptr_t deopt_id = (deopt_target != nullptr)
@@ -2129,18 +2124,16 @@ class PhiUnboxingHeuristic : public ValueObject {
     auto new_representation = phi->representation();
     switch (phi->Type()->ToCid()) {
       case kDoubleCid:
-        if (CanUnboxDouble()) {
-          new_representation = DetermineIfAnyIncomingUnboxedFloats(phi)
-                                   ? kUnboxedFloat
-                                   : kUnboxedDouble;
+        new_representation = DetermineIfAnyIncomingUnboxedFloats(phi)
+                                 ? kUnboxedFloat
+                                 : kUnboxedDouble;
 #if defined(DEBUG)
-          if (new_representation == kUnboxedFloat) {
-            for (auto input : phi->inputs()) {
-              ASSERT(input->representation() != kUnboxedDouble);
-            }
+        if (new_representation == kUnboxedFloat) {
+          for (auto input : phi->inputs()) {
+            ASSERT(input->representation() != kUnboxedDouble);
           }
-#endif
         }
+#endif
         break;
       case kFloat32x4Cid:
         if (ShouldInlineSimd()) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.h b/runtime/vm/compiler/backend/flow_graph_compiler.h
index 5e5e619b4dc..97ea656bf62 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.h
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.h
@@ -392,7 +392,6 @@ class FlowGraphCompiler : public ValueObject {
 
   ~FlowGraphCompiler();
 
-  static bool SupportsUnboxedDoubles();
   static bool SupportsUnboxedSimd128();
   static bool CanConvertInt64ToDouble();
 
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
index e29df6ffd24..f139bfa431d 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
@@ -26,7 +26,6 @@
 namespace dart {
 
 DEFINE_FLAG(bool, trap_on_deoptimization, false, "Trap on deoptimization.");
-DEFINE_FLAG(bool, unbox_doubles, true, "Optimize double arithmetic.");
 DECLARE_FLAG(bool, enable_simd_inline);
 
 void FlowGraphCompiler::ArchSpecificInitialization() {
@@ -66,10 +65,6 @@ FlowGraphCompiler::~FlowGraphCompiler() {
   }
 }
 
-bool FlowGraphCompiler::SupportsUnboxedDoubles() {
-  return FLAG_unbox_doubles;
-}
-
 bool FlowGraphCompiler::SupportsUnboxedSimd128() {
   return TargetCPUFeatures::neon_supported() && FLAG_enable_simd_inline;
 }
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
index d44f56c1c6d..a623e9e3e7a 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
@@ -62,10 +62,6 @@ FlowGraphCompiler::~FlowGraphCompiler() {
   }
 }
 
-bool FlowGraphCompiler::SupportsUnboxedDoubles() {
-  return true;
-}
-
 bool FlowGraphCompiler::SupportsUnboxedSimd128() {
   return FLAG_enable_simd_inline;
 }
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
index d4ca3e7e00b..0e05e3cc1e2 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
@@ -41,10 +41,6 @@ FlowGraphCompiler::~FlowGraphCompiler() {
   }
 }
 
-bool FlowGraphCompiler::SupportsUnboxedDoubles() {
-  return true;
-}
-
 bool FlowGraphCompiler::SupportsUnboxedSimd128() {
   return FLAG_enable_simd_inline;
 }
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc b/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc
index ef6b91992f1..33e8b9e0d5e 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc
@@ -43,10 +43,6 @@ FlowGraphCompiler::~FlowGraphCompiler() {
   }
 }
 
-bool FlowGraphCompiler::SupportsUnboxedDoubles() {
-  return true;
-}
-
 bool FlowGraphCompiler::SupportsUnboxedSimd128() {
   // TODO(riscv): Dynamically test for the vector extension and otherwise
   // allocate SIMD values to register-pairs or quads?
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
index 66e1045c56f..815b1055f17 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
@@ -63,10 +63,6 @@ FlowGraphCompiler::~FlowGraphCompiler() {
   }
 }
 
-bool FlowGraphCompiler::SupportsUnboxedDoubles() {
-  return true;
-}
-
 bool FlowGraphCompiler::SupportsUnboxedSimd128() {
   return FLAG_enable_simd_inline;
 }
diff --git a/runtime/vm/compiler/backend/flow_graph_test.cc b/runtime/vm/compiler/backend/flow_graph_test.cc
index e5c00bfcae7..505928aae9f 100644
--- a/runtime/vm/compiler/backend/flow_graph_test.cc
+++ b/runtime/vm/compiler/backend/flow_graph_test.cc
@@ -296,10 +296,6 @@ ISOLATE_UNIT_TEST_CASE(FlowGraph_LargeFrame_Float64x2) {
 }
 
 ISOLATE_UNIT_TEST_CASE(FlowGraph_PhiUnboxingHeuristic_Double) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
-    return;
-  }
-
   const char* kScript = R"(
     double foo(double sum, int n) {
        if (sum == null) return 0.0;
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index 6839bbe2485..94c22ce8b72 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -4058,7 +4058,6 @@ UnboxInstr* UnboxInstr::Create(Representation to,
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4:
-      ASSERT(FlowGraphCompiler::SupportsUnboxedDoubles());
       return new UnboxInstr(to, value, deopt_id, speculative_mode);
 
     default:
diff --git a/runtime/vm/compiler/call_specializer.cc b/runtime/vm/compiler/call_specializer.cc
index 6a0fe9d713f..31892523040 100644
--- a/runtime/vm/compiler/call_specializer.cc
+++ b/runtime/vm/compiler/call_specializer.cc
@@ -30,10 +30,6 @@ static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
-static bool CanUnboxDouble() {
-  return FlowGraphCompiler::SupportsUnboxedDoubles();
-}
-
 static bool CanConvertInt64ToDouble() {
   return FlowGraphCompiler::CanConvertInt64ToDouble();
 }
@@ -43,11 +39,6 @@ static bool IsNumberCid(intptr_t cid) {
 }
 
 static bool ShouldSpecializeForDouble(const BinaryFeedback& binary_feedback) {
-  // Don't specialize for double if we can't unbox them.
-  if (!CanUnboxDouble()) {
-    return false;
-  }
-
   // Unboxed double operation can't handle case of two smis.
   if (binary_feedback.IncludesOperands(kSmiCid)) {
     return false;
@@ -394,7 +385,7 @@ bool CallSpecializer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
     cid = kSmiCid;
   } else if (binary_feedback.OperandsAreSmiOrMint()) {
     cid = kMintCid;
-  } else if (binary_feedback.OperandsAreSmiOrDouble() && CanUnboxDouble()) {
+  } else if (binary_feedback.OperandsAreSmiOrDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
@@ -469,7 +460,7 @@ bool CallSpecializer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
     cid = kSmiCid;
   } else if (binary_feedback.OperandsAreSmiOrMint()) {
     cid = kMintCid;
-  } else if (binary_feedback.OperandsAreSmiOrDouble() && CanUnboxDouble()) {
+  } else if (binary_feedback.OperandsAreSmiOrDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
@@ -605,9 +596,6 @@ bool CallSpecializer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   if (operands_type == kDoubleCid) {
-    if (!CanUnboxDouble()) {
-      return false;
-    }
     // Check that either left or right are not a smi.  Result of a
     // binary operation with two smis is a smi not a double, except '/' which
     // returns a double for two smis.
@@ -704,7 +692,7 @@ bool CallSpecializer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
     unary_op = new (Z)
         UnaryInt64OpInstr(op_kind, new (Z) Value(input), call->deopt_id());
   } else if (call->Targets().ReceiverIs(kDoubleCid) &&
-             (op_kind == Token::kNEGATE) && CanUnboxDouble()) {
+             (op_kind == Token::kNEGATE)) {
     AddReceiverCheck(call);
     unary_op = new (Z) UnaryDoubleOpInstr(Token::kNEGATE, new (Z) Value(input),
                                           call->deopt_id());
@@ -976,8 +964,7 @@ bool CallSpecializer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   intptr_t receiver_cid = targets.MonomorphicReceiverCid();
   MethodRecognizer::Kind recognized_kind = target.recognized_kind();
 
-  if (CanUnboxDouble() &&
-      (recognized_kind == MethodRecognizer::kIntegerToDouble)) {
+  if (recognized_kind == MethodRecognizer::kIntegerToDouble) {
     if (receiver_cid == kSmiCid) {
       AddReceiverCheck(call);
       ReplaceCall(call,
@@ -994,9 +981,6 @@ bool CallSpecializer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   }
 
   if (receiver_cid == kDoubleCid) {
-    if (!CanUnboxDouble()) {
-      return false;
-    }
     switch (recognized_kind) {
       case MethodRecognizer::kDoubleToInteger: {
         AddReceiverCheck(call);
@@ -1292,8 +1276,7 @@ void CallSpecializer::VisitStaticCall(StaticCallInstr* call) {
       case MethodRecognizer::kMathMax: {
         // We can handle only monomorphic min/max call sites with both arguments
         // being either doubles or smis.
-        if (CanUnboxDouble() && targets.IsMonomorphic() &&
-            (call->FirstArgIndex() == 0)) {
+        if (targets.IsMonomorphic() && (call->FirstArgIndex() == 0)) {
           intptr_t result_cid = kIllegalCid;
           if (binary_feedback.IncludesOperands(kDoubleCid)) {
             result_cid = kDoubleCid;
@@ -1319,20 +1302,18 @@ void CallSpecializer::VisitStaticCall(StaticCallInstr* call) {
       case MethodRecognizer::kDoubleFromInteger: {
         if (call->HasICData() && targets.IsMonomorphic() &&
             (call->FirstArgIndex() == 0)) {
-          if (CanUnboxDouble()) {
-            if (binary_feedback.ArgumentIs(kSmiCid)) {
-              Definition* arg = call->ArgumentAt(1);
-              AddCheckSmi(arg, call->deopt_id(), call->env(), call);
-              ReplaceCall(call, new (Z) SmiToDoubleInstr(new (Z) Value(arg),
-                                                         call->source()));
-              return;
-            } else if (binary_feedback.ArgumentIs(kMintCid) &&
-                       CanConvertInt64ToDouble()) {
-              Definition* arg = call->ArgumentAt(1);
-              ReplaceCall(call, new (Z) Int64ToDoubleInstr(new (Z) Value(arg),
-                                                           call->deopt_id()));
-              return;
-            }
+          if (binary_feedback.ArgumentIs(kSmiCid)) {
+            Definition* arg = call->ArgumentAt(1);
+            AddCheckSmi(arg, call->deopt_id(), call->env(), call);
+            ReplaceCall(call, new (Z) SmiToDoubleInstr(new (Z) Value(arg),
+                                                       call->source()));
+            return;
+          } else if (binary_feedback.ArgumentIs(kMintCid) &&
+                     CanConvertInt64ToDouble()) {
+            Definition* arg = call->ArgumentAt(1);
+            ReplaceCall(call, new (Z) Int64ToDoubleInstr(new (Z) Value(arg),
+                                                         call->deopt_id()));
+            return;
           }
         }
         break;
@@ -1521,15 +1502,10 @@ void TypedDataSpecializer::TryInlineCall(TemplateDartCall<0>* call) {
 
     auto const rep =
         RepresentationUtils::RepresentationOfArrayElement(variant.array_cid);
-    const bool is_float_access = rep == kUnboxedFloat || rep == kUnboxedDouble;
     const bool is_simd_access = rep == kUnboxedInt32x4 ||
                                 rep == kUnboxedFloat32x4 ||
                                 rep == kUnboxedFloat64x2;
 
-    if (is_float_access && !FlowGraphCompiler::SupportsUnboxedDoubles()) {
-      return;
-    }
-
     if (is_simd_access && !FlowGraphCompiler::SupportsUnboxedSimd128()) {
       return;
     }
@@ -1984,9 +1960,6 @@ static bool InlineDoubleOp(FlowGraph* flow_graph,
                            FunctionEntryInstr** entry,
                            Instruction** last,
                            Definition** result) {
-  if (!CanUnboxDouble()) {
-    return false;
-  }
   Definition* left = receiver;
   Definition* right = call->ArgumentAt(1);
 
@@ -2013,10 +1986,6 @@ static bool InlineDoubleTestOp(FlowGraph* flow_graph,
                                FunctionEntryInstr** entry,
                                Instruction** last,
                                Definition** result) {
-  if (!CanUnboxDouble()) {
-    return false;
-  }
-
   *entry =
       new (Z) FunctionEntryInstr(graph_entry, flow_graph->allocate_block_id(),
                                  call->GetBlock()->try_index(), DeoptId::kNone);
@@ -3183,9 +3152,6 @@ bool CallSpecializer::TryInlineRecognizedMethod(
                               call, receiver, graph_entry, entry, last, result);
     case MethodRecognizer::kFloat32ArrayGetIndexed:
     case MethodRecognizer::kFloat64ArrayGetIndexed:
-      if (!CanUnboxDouble()) {
-        return false;
-      }
       return InlineGetIndexed(flow_graph, can_speculate, is_dynamic_call, kind,
                               call, receiver, graph_entry, entry, last, result);
     case MethodRecognizer::kFloat32x4ArrayGetIndexed:
@@ -3241,9 +3207,6 @@ bool CallSpecializer::TryInlineRecognizedMethod(
 
     case MethodRecognizer::kFloat32ArraySetIndexed:
     case MethodRecognizer::kFloat64ArraySetIndexed: {
-      if (!CanUnboxDouble()) {
-        return false;
-      }
       return InlineSetIndexed(flow_graph, kind, target, call, receiver, source,
                               exactness, graph_entry, entry, last, result);
     }
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 28a2213aace..5d146140e80 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -869,9 +869,6 @@ Fragment FlowGraphBuilder::NativeFunctionBody(const Function& function,
 
 static bool CanUnboxElements(classid_t cid) {
   switch (RepresentationUtils::RepresentationOfArrayElement(cid)) {
-    case kUnboxedFloat:
-    case kUnboxedDouble:
-      return FlowGraphCompiler::SupportsUnboxedDoubles();
     case kUnboxedInt32x4:
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
@@ -1142,10 +1139,9 @@ bool FlowGraphBuilder::IsRecognizedMethodForFlowGraph(
     case MethodRecognizer::kMathExp:
     case MethodRecognizer::kMathLog:
     case MethodRecognizer::kMathSqrt:
-      return FlowGraphCompiler::SupportsUnboxedDoubles();
+      return true;
     case MethodRecognizer::kDoubleCeilToInt:
     case MethodRecognizer::kDoubleFloorToInt:
-      if (!FlowGraphCompiler::SupportsUnboxedDoubles()) return false;
 #if defined(TARGET_ARCH_X64)
       return CompilerState::Current().is_aot() || FLAG_target_unknown_cpu;
 #elif defined(TARGET_ARCH_ARM64) || defined(TARGET_ARCH_RISCV32) ||            \
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
index 98bdcd2980b..813b37a9124 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.cc
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -3851,9 +3851,7 @@ static void SetupUnboxingInfoOfParameter(const Function& function,
         function.set_unboxed_integer_parameter_at(param_pos);
         break;
       case UnboxingInfoMetadata::kDouble:
-        if (FlowGraphCompiler::SupportsUnboxedDoubles()) {
-          function.set_unboxed_double_parameter_at(param_pos);
-        }
+        function.set_unboxed_double_parameter_at(param_pos);
         break;
       case UnboxingInfoMetadata::kRecord:
         UNREACHABLE();
@@ -3875,9 +3873,7 @@ static void SetupUnboxingInfoOfReturnValue(
       function.set_unboxed_integer_return();
       break;
     case UnboxingInfoMetadata::kDouble:
-      if (FlowGraphCompiler::SupportsUnboxedDoubles()) {
-        function.set_unboxed_double_return();
-      }
+      function.set_unboxed_double_return();
       break;
     case UnboxingInfoMetadata::kRecord:
       function.set_unboxed_record_return();
diff --git a/runtime/vm/compiler/graph_intrinsifier.cc b/runtime/vm/compiler/graph_intrinsifier.cc
index 827237312a8..3d44b325213 100644
--- a/runtime/vm/compiler/graph_intrinsifier.cc
+++ b/runtime/vm/compiler/graph_intrinsifier.cc
@@ -302,9 +302,6 @@ DEFINE_ARRAY_SETTER_INTRINSIC(Uint64Array)
 #define DEFINE_FLOAT_ARRAY_SETTER_INTRINSIC(enum_name)                         \
   bool GraphIntrinsifier::Build_##enum_name##SetIndexed(                       \
       FlowGraph* flow_graph) {                                                 \
-    if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {                        \
-      return false;                                                            \
-    }                                                                          \
     return IntrinsifyArraySetIndexed(                                          \
         flow_graph, MethodRecognizer::MethodKindToReceiverCid(                 \
                         MethodRecognizer::k##enum_name##SetIndexed));          \
@@ -401,8 +398,7 @@ bool GraphIntrinsifier::Build_Float64x2Add(FlowGraph* flow_graph) {
 
 static bool BuildFloat32x4Get(FlowGraph* flow_graph,
                               MethodRecognizer::Kind kind) {
-  if (!FlowGraphCompiler::SupportsUnboxedDoubles() ||
-      !FlowGraphCompiler::SupportsUnboxedSimd128()) {
+  if (!FlowGraphCompiler::SupportsUnboxedSimd128()) {
     return false;
   }
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
@@ -705,9 +701,6 @@ static Definition* ConvertOrUnboxDoubleParameter(BlockBuilder* builder,
 }
 
 bool GraphIntrinsifier::Build_DoubleFlipSignBit(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, /*with_frame=*/false);
diff --git a/runtime/vm/compiler/runtime_api.cc b/runtime/vm/compiler/runtime_api.cc
index 3779a4aecda..4122bb3dd81 100644
--- a/runtime/vm/compiler/runtime_api.cc
+++ b/runtime/vm/compiler/runtime_api.cc
@@ -1089,9 +1089,7 @@ void UnboxFieldIfSupported(const dart::Field& field,
 
   classid_t cid = kIllegalCid;
   if (type.IsDoubleType()) {
-    if (FlowGraphCompiler::SupportsUnboxedDoubles()) {
-      cid = kDoubleCid;
-    }
+    cid = kDoubleCid;
   } else if (type.IsFloat32x4Type()) {
     if (FlowGraphCompiler::SupportsUnboxedSimd128()) {
       cid = kFloat32x4Cid;
diff --git a/runtime/vm/deopt_instructions.h b/runtime/vm/deopt_instructions.h
index 4ff23f9ea81..0b7bce2fca9 100644
--- a/runtime/vm/deopt_instructions.h
+++ b/runtime/vm/deopt_instructions.h
@@ -83,7 +83,6 @@ class DeoptContext : public MallocAllocated {
   }
 
   float FpuRegisterValueAsFloat(FpuRegister reg) const {
-    ASSERT(FlowGraphCompiler::SupportsUnboxedDoubles());
     ASSERT(fpu_registers_ != NULL);
     ASSERT(reg >= 0);
     ASSERT(reg < kNumberOfFpuRegisters);
@@ -91,7 +90,6 @@ class DeoptContext : public MallocAllocated {
   }
 
   double FpuRegisterValueAsDouble(FpuRegister reg) const {
-    ASSERT(FlowGraphCompiler::SupportsUnboxedDoubles());
     ASSERT(fpu_registers_ != nullptr);
     ASSERT(reg >= 0);
     ASSERT(reg < kNumberOfFpuRegisters);
diff --git a/runtime/vm/kernel_loader.cc b/runtime/vm/kernel_loader.cc
index b35578305b8..5d5d72fc854 100644
--- a/runtime/vm/kernel_loader.cc
+++ b/runtime/vm/kernel_loader.cc
@@ -764,8 +764,7 @@ void KernelLoader::ReadInferredType(const Field& field,
   if (FLAG_precompiled_mode) {
     field.set_is_unboxed(!field.is_late() && !field.is_static() &&
                          !field.is_nullable() &&
-                         ((field.guarded_cid() == kDoubleCid &&
-                           FlowGraphCompiler::SupportsUnboxedDoubles()) ||
+                         ((field.guarded_cid() == kDoubleCid) ||
                           (field.guarded_cid() == kFloat32x4Cid &&
                            FlowGraphCompiler::SupportsUnboxedSimd128()) ||
                           (field.guarded_cid() == kFloat64x2Cid &&