[vm] Support loading unboxed float consts to stack

Split off https://dart-review.googlesource.com/c/sdk/+/284300.

Doubles are always loaded to DoubleStackSlots, and should already
be covered.

TEST=tested in dependent CL.
If the code was moved to the assemblers, and the assemblers were given
access to `Location`, this could be unit tested in an assembler test.
See issue for discussion.

Closes: #53900
Change-Id: Iaed2cf1fadebebd1857709cb5d7cc3b41a3d9747
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/332761
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Daco Harkes <[email protected]>

Author: dcharkes

runtime/vm/compiler/backend/il_arm.cc

@@ -910,7 +910,12 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
       RELEASE_ASSERT(ok);
       __ LoadImmediate(
           tmp, pair_index == 0 ? Utils::Low32Bits(v) : Utils::High32Bits(v));
+    } else if (representation() == kUnboxedFloat) {
+      int32_t float_bits =
+          bit_cast<int32_t, float>(Double::Cast(value_).value());
+      __ LoadImmediate(tmp, float_bits);
     } else {
+      ASSERT(representation() == kTagged);
       __ LoadObject(tmp, value_);
     }
     __ StoreToOffset(tmp, destination.base_reg(), dest_offset);

runtime/vm/compiler/backend/il_arm64.cc

@@ -725,6 +725,7 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
     ASSERT(destination.IsStackSlot());
     ASSERT(tmp != kNoRegister);
     const intptr_t dest_offset = destination.ToStackSlotOffset();
+    compiler::OperandSize operand_size = compiler::kWordBytes;
     if (representation() == kUnboxedInt32 ||
         representation() == kUnboxedUint32 ||
         representation() == kUnboxedInt64) {
@@ -734,6 +735,11 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
       } else {
         __ LoadImmediate(tmp, value);
       }
+    } else if (representation() == kUnboxedFloat) {
+      int32_t float_bits =
+          bit_cast<int32_t, float>(Double::Cast(value_).value());
+      __ LoadImmediate(tmp, float_bits);
+      operand_size = compiler::kFourBytes;
     } else {
       ASSERT(representation() == kTagged);
       if (value_.IsNull()) {
@@ -744,7 +750,7 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
         __ LoadObject(tmp, value_);
       }
     }
-    __ StoreToOffset(tmp, destination.base_reg(), dest_offset);
+    __ StoreToOffset(tmp, destination.base_reg(), dest_offset, operand_size);
   }
 }
 

runtime/vm/compiler/backend/il_ia32.cc

@@ -507,7 +507,13 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
       __ movl(LocationToStackSlotAddress(destination),
               compiler::Immediate(pair_index == 0 ? Utils::Low32Bits(v)
                                                   : Utils::High32Bits(v)));
+    } else if (representation() == kUnboxedFloat) {
+      int32_t float_bits =
+          bit_cast<int32_t, float>(Double::Cast(value_).value());
+      __ movl(LocationToStackSlotAddress(destination),
+              compiler::Immediate(float_bits));
     } else {
+      ASSERT(representation() == kTagged);
       if (compiler::Assembler::IsSafeSmi(value_) || value_.IsNull()) {
         __ movl(LocationToStackSlotAddress(destination),
                 compiler::Immediate(static_cast<int32_t>(value_.ptr())));

runtime/vm/compiler/backend/il_riscv.cc

@@ -799,6 +799,7 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
     ASSERT(destination.IsStackSlot());
     ASSERT(tmp != kNoRegister);
     const intptr_t dest_offset = destination.ToStackSlotOffset();
+    compiler::OperandSize operand_size = compiler::kWordBytes;
     if (RepresentationUtils::IsUnboxedInteger(representation())) {
       int64_t val = Integer::Cast(value_).AsInt64Value();
 #if XLEN == 32
@@ -811,6 +812,11 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
       } else {
         __ LoadImmediate(tmp, val);
       }
+    } else if (representation() == kUnboxedFloat) {
+      int32_t float_bits =
+          bit_cast<int32_t, float>(Double::Cast(value_).value());
+      __ LoadImmediate(tmp, float_bits);
+      operand_size = compiler::kFourBytes;
     } else {
       ASSERT(representation() == kTagged);
       if (value_.IsNull()) {
@@ -821,7 +827,7 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
         __ LoadObject(tmp, value_);
       }
     }
-    __ StoreToOffset(tmp, destination.base_reg(), dest_offset);
+    __ StoreToOffset(tmp, destination.base_reg(), dest_offset, operand_size);
   }
 }
 

runtime/vm/compiler/backend/il_x64.cc

@@ -659,6 +659,11 @@ void ConstantInstr::EmitMoveToLocation(FlowGraphCompiler* compiler,
       const int64_t value = Integer::Cast(value_).AsInt64Value();
       __ movq(LocationToStackSlotAddress(destination),
               compiler::Immediate(value));
+    } else if (representation() == kUnboxedFloat) {
+      int32_t float_bits =
+          bit_cast<int32_t, float>(Double::Cast(value_).value());
+      __ movl(LocationToStackSlotAddress(destination),
+              compiler::Immediate(float_bits));
     } else {
       ASSERT(representation() == kTagged);
       __ StoreObject(LocationToStackSlotAddress(destination), value_);