[vm] Finish Int32x4 unboxing, symmetric to the float SIMD value types

Fixes SimdFields: i32x4Field goes 2409us -> 475us in AOT and 2838us -> 730us
in JIT.

TEST=vm/cc/IsolateReload_ExistingInt32x4FieldUnboxedToUnboxed

Issue: #64170
Change-Id: I645f80a795e12f8c9d0de75b95b2163c6c04c6ec
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/543040
Commit-Queue: Slava Egorov <vegorov@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Auto-Submit: Modestas Valauskas <valauskasmodestas@gmail.com>
Reviewed-by: Slava Egorov <vegorov@google.com>

Author: modulovalue

pkg/native_compiler/lib/runtime/vm_offsets.g.dart

@@ -217,6 +217,8 @@ void SnapshotAnalyzer::DumpClassInstanceSlots(
           slots = sizeof(simd128_value_t) / kCompressedWordSize;
         } else if (type.IsFloat64x2Type()) {
           slots = sizeof(simd128_value_t) / kCompressedWordSize;
+        } else if (type.IsInt32x4Type()) {
+          slots = sizeof(simd128_value_t) / kCompressedWordSize;
         } else {
           // Rare: Could be that the field type isn't telling us the unboxed
           // type but field is still unboxed (e.g. `dynamic` field which TFA
@@ -382,6 +384,8 @@ void SnapshotAnalyzer::DumpField(const Field& field) {
       unboxed_type = "Float32x4";
     } else if (type.IsFloat64x2Type()) {
       unboxed_type = "Float64x2";
+    } else if (type.IsInt32x4Type()) {
+      unboxed_type = "Int32x4";
     } else {
       unboxed_type = "unknown";
     }

runtime/vm/analyze_snapshot_api_impl.cc

@@ -524,6 +524,9 @@ void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
         case kUnboxedFloat64x2:
           stub = &StubCode::BoxFloat64x2();
           break;
+        case kUnboxedInt32x4:
+          stub = &StubCode::BoxInt32x4();
+          break;
         default:
           UNREACHABLE();
           break;
@@ -1774,6 +1777,7 @@ void FlowGraphCompiler::AllocateRegistersLocally(Instruction* instr) {
           break;
         case kUnboxedFloat32x4:
         case kUnboxedFloat64x2:
+        case kUnboxedInt32x4:
           ASSERT(fpu_reg != kNoFpuRegister);
           assembler()->LoadUnboxedSimd128(
               fpu_reg, reg,
@@ -3030,7 +3034,7 @@ void FlowGraphCompiler::FrameStatePush(Definition* defn) {
   Representation rep = defn->representation();
   ASSERT(!is_optimizing());
   if ((rep == kUnboxedDouble || rep == kUnboxedFloat32x4 ||
-       rep == kUnboxedFloat64x2) &&
+       rep == kUnboxedFloat64x2 || rep == kUnboxedInt32x4) &&
       defn->locs()->out(0).IsFpuRegister()) {
     // Output value is boxed in the instruction epilogue.
     rep = kTagged;

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -4823,6 +4823,7 @@ void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
         break;
       case kFloat32x4Cid:
       case kFloat64x2Cid:
+      case kInt32x4Cid:
         __ LoadUnboxedSimd128(result, instance_reg,
                               OffsetInBytes() - kHeapObjectTag);
         break;
@@ -6430,7 +6431,8 @@ void BoxAllocationSlowPath::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!kAllocateMintRuntimeEntry.can_lazy_deopt() &&
          !kAllocateDoubleRuntimeEntry.can_lazy_deopt() &&
          !kAllocateFloat32x4RuntimeEntry.can_lazy_deopt() &&
-         !kAllocateFloat64x2RuntimeEntry.can_lazy_deopt());
+         !kAllocateFloat64x2RuntimeEntry.can_lazy_deopt() &&
+         !kAllocateInt32x4RuntimeEntry.can_lazy_deopt());
   compiler->GenerateNonLazyDeoptableStubCall(
       InstructionSource(),  // No token position.
       stub, UntaggedPcDescriptors::kOther, locs);
@@ -8275,6 +8277,7 @@ void StoreFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
         return;
       case kFloat32x4Cid:
       case kFloat64x2Cid:
+      case kInt32x4Cid:
         __ StoreUnboxedSimd128(value, instance_reg,
                                OffsetInBytes() - kHeapObjectTag);
         return;

runtime/vm/compiler/backend/il.cc

@@ -438,6 +438,9 @@ const Slot& Slot::Get(const Field& field,
       case kFloat64x2Cid:
         rep = kUnboxedFloat64x2;
         break;
+      case kInt32x4Cid:
+        rep = kUnboxedInt32x4;
+        break;
       default:
         rep = kUnboxedInt64;
         break;

runtime/vm/compiler/backend/slot.cc

@@ -1068,6 +1068,10 @@ void UnboxFieldIfSupported(const dart::Field& field,
     if (FlowGraphCompiler::SupportsUnboxedSimd128()) {
       cid = kFloat64x2Cid;
     }
+  } else if (type.IsInt32x4Type()) {
+    if (FlowGraphCompiler::SupportsUnboxedSimd128()) {
+      cid = kInt32x4Cid;
+    }
   }
 
   if (cid != kIllegalCid) {

runtime/vm/compiler/runtime_api.cc

@@ -1850,6 +1850,16 @@ void StubCodeCompiler::GenerateBoxFloat64x2Stub() {
 #endif
 }
 
+void StubCodeCompiler::GenerateBoxInt32x4Stub() {
+#if !defined(TARGET_ARCH_RISCV32) && !defined(TARGET_ARCH_RISCV64)
+  GenerateBoxFpuValueStub(assembler, compiler::Int32x4Class(),
+                          kBoxInt32x4RuntimeEntry,
+                          &Assembler::StoreUnboxedSimd128);
+#else
+  __ Stop("Not supported on RISC-V.");
+#endif
+}
+
 void StubCodeCompiler::GenerateDoubleToIntegerStub() {
   __ EnterStubFrame();
   __ StoreUnboxedDouble(DoubleToIntegerStubABI::kInputReg, THR,

runtime/vm/compiler/runtime_offsets_extracted.h

@@ -2867,6 +2867,14 @@ ObjectPtr Interpreter::Run(Thread* thread,
               offset_in_words) = raw_value;
           break;
         }
+        case kInt32x4Cid: {
+          simd128_value_t raw_value;
+          raw_value.readFrom(Int32x4::RawCast(value)->untag()->value_);
+          *reinterpret_cast<simd128_value_t*>(
+              reinterpret_cast<CompressedObjectPtr*>(instance->untag()) +
+              offset_in_words) = raw_value;
+          break;
+        }
         default: {
           int64_t raw_value = Integer::Value(Integer::RawCast(value));
           *reinterpret_cast<int64_t*>(

runtime/vm/compiler/stub_code_compiler.cc

@@ -172,6 +172,7 @@ InstanceMorpher* InstanceMorpher::CreateFromClassDescriptors(
             case kDoubleCid:
             case kFloat32x4Cid:
             case kFloat64x2Cid:
+            case kInt32x4Cid:
               from_box_cid = field_cid;
               break;
             default:
@@ -186,6 +187,7 @@ InstanceMorpher* InstanceMorpher::CreateFromClassDescriptors(
             case kDoubleCid:
             case kFloat32x4Cid:
             case kFloat64x2Cid:
+            case kInt32x4Cid:
               to_box_cid = field_cid;
               break;
             default:
@@ -310,6 +312,12 @@ void InstanceMorpher::CreateMorphedCopies(Become* become) {
             value = Float64x2::New(unboxed_value);
             break;
           }
+          case kInt32x4Cid: {
+            const auto unboxed_value =
+                before.RawGetUnboxedFieldAtOffset<simd128_value_t>(from.offset);
+            value = Int32x4::New(unboxed_value);
+            break;
+          }
           case kIntegerCid: {
             const auto unboxed_value =
                 before.RawGetUnboxedFieldAtOffset<int64_t>(from.offset);
@@ -332,7 +340,8 @@ void InstanceMorpher::CreateMorphedCopies(Become* become) {
             break;
           }
           case kFloat32x4Cid:
-          case kFloat64x2Cid: {
+          case kFloat64x2Cid:
+          case kInt32x4Cid: {
             const auto unboxed_value =
                 before.RawGetUnboxedFieldAtOffset<simd128_value_t>(from.offset);
             after.RawSetUnboxedFieldAtOffset<simd128_value_t>(to.offset,
@@ -371,6 +380,8 @@ static const char* BoxCidToCString(intptr_t box_cid) {
       return "float32x4";
     case kFloat64x2Cid:
       return "float64x2";
+    case kInt32x4Cid:
+      return "int32x4";
     case kIntegerCid:
       return "int64";
   }