[vm, ffi] Don't read out-of-bounds when marshalling structs by value.
Switch the Windows ARM64 builds to use MSVC. Clang disagrees with itself about handling of small structs in variadic functions, allowing splitting between the last argument register and the stack as the callee but not as the caller.
TEST=ci
Cq-Include-Trybots: luci.dart.try:vm-ffi-android-debug-arm-try,vm-ffi-android-debug-arm64c-try,vm-ffi-android-release-arm-try,vm-ffi-android-release-arm64c-try,vm-ffi-qemu-linux-release-arm-try,vm-linux-release-arm64-try,vm-mac-debug-arm64-try,vm-mac-release-arm64-try,vm-win-debug-arm64-try,vm-win-release-arm64-try,vm-ffi-qemu-linux-release-riscv64-try,vm-linux-debug-ia32-try,vm-linux-release-ia32-try,vm-win-release-ia32-try,vm-linux-debug-x64-try,vm-linux-release-x64-try,vm-mac-debug-x64-try,vm-mac-release-x64-try,vm-win-debug-x64-try,vm-win-release-x64-try
Bug: https://github.com/dart-lang/sdk/issues/52644
Bug: https://github.com/dart-lang/sdk/issues/53829
Change-Id: I2fd6c40620a885479f11bb8528ca1e9df3948a2f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/331209
Commit-Queue: Ryan Macnak <rmacnak@google.com>
Reviewed-by: Daco Harkes <dacoharkes@google.com>
Reviewed-by: Siva Annamalai <asiva@google.com>
diff --git a/runtime/bin/ffi_test/ffi_test_functions.cc b/runtime/bin/ffi_test/ffi_test_functions.cc
index 4daf7aa..7bc707a 100644
--- a/runtime/bin/ffi_test/ffi_test_functions.cc
+++ b/runtime/bin/ffi_test/ffi_test_functions.cc
@@ -734,6 +734,23 @@
return s9.a0 + s9.a1 + s9.a2 + s9.a3 + s9.a4 + s9.a5 + s9.a6 + s9.a7 + s9.a8;
}
+DART_EXPORT int64_t
+SumReturnStruct9Uint8(Struct9Uint8 (*callback)(Struct9Uint8*),
+ Struct9Uint8* in) {
+ std::cout << "SumReturnStruct9Uint8 in (" << in->a0 << ", " << in->a1 << ", "
+ << in->a2 << ", " << in->a3 << ", " << in->a4 << ", " << in->a5
+ << ", " << in->a6 << ", " << in->a7 << ", " << in->a8 << ")\n";
+
+ Struct9Uint8 out = callback(in);
+
+ std::cout << "SumReturnStruct9Uint8 out (" << out.a0 << ", " << out.a1 << ", "
+ << out.a2 << ", " << out.a3 << ", " << out.a4 << ", " << out.a5
+ << ", " << out.a6 << ", " << out.a7 << ", " << out.a8 << ")\n";
+
+ return out.a0 + out.a1 + out.a2 + out.a3 + out.a4 + out.a5 + out.a6 + out.a7 +
+ out.a8;
+}
+
// Allocates a multiple of the larest page size, so the last element of the
// array is right at a page boundary. Explicitly allocate and make inaccessible
// the next page to avoid flaky false-successes if the next page happens to be
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 8b21683..b5bc26d 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -3292,6 +3292,13 @@
if (src_payload_type.IsInt() && dst_payload_type.IsInt() &&
(src_payload_size != src_container_size ||
dst_payload_size != dst_container_size)) {
+ if (source.IsStack() && src_container_size > src_payload_size) {
+ // Shrink loads since all loads are extending.
+ return EmitNativeMove(
+ destination,
+ source.WithOtherNativeType(zone_, src_payload_type, src_payload_type),
+ temp);
+ }
if (src_payload_size <= dst_payload_size &&
src_container_size >= dst_container_size) {
// The upper bits of the source are already properly sign or zero
@@ -3361,32 +3368,6 @@
return;
}
-#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
- // Arm does not support sign extending from a memory location, x86 does.
- if (sign_or_zero_extend && source.IsStack()) {
- ASSERT(destination.IsRegisters());
- const auto& intermediate = destination.WithOtherNativeType(
- zone_, src_payload_type, src_container_type);
- EmitNativeMove(intermediate, source, temp);
- EmitNativeMove(destination, intermediate, temp);
- return;
- }
-#endif
-
- // If we're not sign extending, and we're moving 8 or 16 bits into a
- // register, upgrade the move to take upper bits of garbage from the
- // source location. This is the same as leaving the previous garbage in
- // there.
- //
- // TODO(40210): If our assemblers would support moving 1 and 2 bytes into
- // registers, this code can be removed.
- if (!sign_or_zero_extend && destination.IsRegisters() &&
- destination.container_type().SizeInBytes() <= 2) {
- ASSERT(source.payload_type().IsInt());
- return EmitNativeMove(destination.WidenTo4Bytes(zone_),
- source.WidenTo4Bytes(zone_), temp);
- }
-
// Do the simple architecture specific moves.
EmitNativeMoveArchitecture(destination, source);
}
@@ -3405,7 +3386,17 @@
} else {
const auto& src =
compiler::ffi::NativeLocation::FromLocation(zone_, src_loc, src_type);
- EmitNativeMove(dst, src, temp);
+ // Deal with sign mismatch caused by lack of kUnboxedUint64 representation.
+ if (src_type == kUnboxedInt64 &&
+ dst.container_type().AsPrimitive().representation() ==
+ compiler::ffi::kUint64) {
+ EmitNativeMove(dst,
+ src.WithOtherNativeType(zone_, dst.container_type(),
+ dst.container_type()),
+ temp);
+ } else {
+ EmitNativeMove(dst, src, temp);
+ }
}
}
@@ -3421,9 +3412,18 @@
EmitNativeMove(dest_split, src.Split(zone_, 2, i), temp);
}
} else {
- const auto& dest =
+ const auto& dst =
compiler::ffi::NativeLocation::FromLocation(zone_, dst_loc, dst_type);
- EmitNativeMove(dest, src, temp);
+ // Deal with sign mismatch caused by lack of kUnboxedUint64 representation.
+ if (dst_type == kUnboxedInt64 &&
+ src.container_type().AsPrimitive().representation() ==
+ compiler::ffi::kUint64) {
+ EmitNativeMove(dst.WithOtherNativeType(zone_, src.container_type(),
+ src.container_type()),
+ src, temp);
+ } else {
+ EmitNativeMove(dst, src, temp);
+ }
}
}
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.h b/runtime/vm/compiler/backend/flow_graph_compiler.h
index 969d2a3..4e58ca1 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.h
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.h
@@ -945,6 +945,10 @@
// Architecture specific implementation of simple native moves.
void EmitNativeMoveArchitecture(const compiler::ffi::NativeLocation& dst,
const compiler::ffi::NativeLocation& src);
+ void EmitNativeLoad(Register dst,
+ Register base,
+ intptr_t offset,
+ compiler::ffi::PrimitiveType type);
void EmitFrameEntry();
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
index 129ef42..49d8e7c 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
@@ -956,9 +956,9 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
+ ASSERT(destination.container_type().SizeInBytes() <= 4);
if (!sign_or_zero_extend) {
- ASSERT(dst_size == 4);
- __ mov(dst_reg, compiler::Operand(src_reg));
+ __ MoveRegister(dst_reg, src_reg);
} else {
if (src_payload_type.IsSigned()) {
__ sbfx(dst_reg, src_reg, 0, src_size * kBitsPerByte);
@@ -977,8 +977,8 @@
ASSERT(destination.IsStack());
const auto& dst = destination.AsStack();
ASSERT(!sign_or_zero_extend);
- ASSERT(dst_size <= 4);
- auto const op_size = BytesToOperandSize(dst_size);
+ auto const op_size =
+ BytesToOperandSize(destination.container_type().SizeInBytes());
__ StoreToOffset(src.reg_at(0), dst.base_register(),
dst.offset_in_bytes(), op_size);
}
@@ -1036,12 +1036,8 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
- ASSERT(!sign_or_zero_extend);
- ASSERT(dst_size <= 4);
- auto const op_size = BytesToOperandSize(dst_size);
- __ LoadFromOffset(dst_reg, src.base_register(), src.offset_in_bytes(),
- op_size);
-
+ EmitNativeLoad(dst_reg, src.base_register(), src.offset_in_bytes(),
+ src_payload_type.AsPrimitive().representation());
} else if (destination.IsFpuRegisters()) {
ASSERT(src_payload_type.Equals(dst_payload_type));
ASSERT(src_payload_type.IsFloat());
@@ -1066,6 +1062,47 @@
}
}
+void FlowGraphCompiler::EmitNativeLoad(Register dst,
+ Register base,
+ intptr_t offset,
+ compiler::ffi::PrimitiveType type) {
+ switch (type) {
+ case compiler::ffi::kInt8:
+ __ LoadFromOffset(dst, base, offset, compiler::kByte);
+ break;
+ case compiler::ffi::kUint8:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedByte);
+ break;
+ case compiler::ffi::kInt16:
+ __ LoadFromOffset(dst, base, offset, compiler::kTwoBytes);
+ break;
+ case compiler::ffi::kUint16:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ break;
+ case compiler::ffi::kInt32:
+ __ LoadFromOffset(dst, base, offset, compiler::kFourBytes);
+ break;
+ case compiler::ffi::kUint32:
+ case compiler::ffi::kFloat:
+ case compiler::ffi::kHalfDouble:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ break;
+
+ case compiler::ffi::kInt24:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ __ LoadFromOffset(TMP, base, offset + 2, compiler::kByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 16));
+ break;
+ case compiler::ffi::kUint24:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ __ LoadFromOffset(TMP, base, offset + 2, compiler::kUnsignedByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 16));
+ break;
+ default:
+ UNREACHABLE();
+ }
+}
+
void FlowGraphCompiler::LoadBSSEntry(BSS::Relocation relocation,
Register dst,
Register tmp) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
index ee8bc71..c983573 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
@@ -944,34 +944,14 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
+ ASSERT(destination.container_type().SizeInBytes() <= 8);
if (!sign_or_zero_extend) {
- switch (dst_size) {
- case 8:
- __ mov(dst_reg, src_reg);
- return;
- case 4:
- __ movw(dst_reg, src_reg);
- return;
- default:
- UNIMPLEMENTED();
- }
+ __ MoveRegister(dst_reg, src_reg);
} else {
- switch (src_payload_type.AsPrimitive().representation()) {
- case compiler::ffi::kInt8: // Sign extend operand.
- __ sxtb(dst_reg, src_reg);
- return;
- case compiler::ffi::kInt16:
- __ sxth(dst_reg, src_reg);
- return;
- case compiler::ffi::kUint8: // Zero extend operand.
- __ uxtb(dst_reg, src_reg);
- return;
- case compiler::ffi::kUint16:
- __ uxth(dst_reg, src_reg);
- return;
- default:
- // 32 to 64 bit is covered in IL by Representation conversions.
- UNIMPLEMENTED();
+ if (src_payload_type.IsSigned()) {
+ __ sbfx(dst_reg, src_reg, 0, src_size * kBitsPerByte);
+ } else {
+ __ ubfx(dst_reg, src_reg, 0, src_size * kBitsPerByte);
}
}
@@ -983,7 +963,8 @@
ASSERT(destination.IsStack());
const auto& dst = destination.AsStack();
ASSERT(!sign_or_zero_extend);
- auto const op_size = BytesToOperandSize(dst_size);
+ auto const op_size =
+ BytesToOperandSize(destination.container_type().SizeInBytes());
__ StoreToOffset(src.reg_at(0), dst.base_register(),
dst.offset_in_bytes(), op_size);
}
@@ -1026,11 +1007,8 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
- ASSERT(!sign_or_zero_extend);
- auto const op_size = BytesToOperandSize(dst_size);
- __ LoadFromOffset(dst_reg, src.base_register(), src.offset_in_bytes(),
- op_size);
-
+ EmitNativeLoad(dst_reg, src.base_register(), src.offset_in_bytes(),
+ src_payload_type.AsPrimitive().representation());
} else if (destination.IsFpuRegisters()) {
ASSERT(src_payload_type.Equals(dst_payload_type));
ASSERT(src_payload_type.IsFloat());
@@ -1055,6 +1033,85 @@
}
}
+void FlowGraphCompiler::EmitNativeLoad(Register dst,
+ Register base,
+ intptr_t offset,
+ compiler::ffi::PrimitiveType type) {
+ switch (type) {
+ case compiler::ffi::kInt8:
+ __ LoadFromOffset(dst, base, offset, compiler::kByte);
+ break;
+ case compiler::ffi::kUint8:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedByte);
+ break;
+ case compiler::ffi::kInt16:
+ __ LoadFromOffset(dst, base, offset, compiler::kTwoBytes);
+ break;
+ case compiler::ffi::kUint16:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ break;
+ case compiler::ffi::kInt32:
+ __ LoadFromOffset(dst, base, offset, compiler::kFourBytes);
+ break;
+ case compiler::ffi::kUint32:
+ case compiler::ffi::kFloat:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ break;
+ case compiler::ffi::kInt64:
+ case compiler::ffi::kUint64:
+ case compiler::ffi::kDouble:
+ __ LoadFromOffset(dst, base, offset, compiler::kEightBytes);
+ break;
+
+ case compiler::ffi::kInt24:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ __ LoadFromOffset(TMP, base, offset + 2, compiler::kByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 16));
+ break;
+ case compiler::ffi::kUint24:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ __ LoadFromOffset(TMP, base, offset + 2, compiler::kUnsignedByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 16));
+ break;
+ case compiler::ffi::kInt40:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 32));
+ break;
+ case compiler::ffi::kUint40:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 32));
+ break;
+ case compiler::ffi::kInt48:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kTwoBytes);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 32));
+ break;
+ case compiler::ffi::kUint48:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedTwoBytes);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 32));
+ break;
+ case compiler::ffi::kInt56:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedTwoBytes);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 32));
+ __ LoadFromOffset(TMP, base, offset + 6, compiler::kByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 48));
+ break;
+ case compiler::ffi::kUint56:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedTwoBytes);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 32));
+ __ LoadFromOffset(TMP, base, offset + 6, compiler::kUnsignedByte);
+ __ orr(dst, dst, compiler::Operand(TMP, LSL, 48));
+ break;
+ default:
+ UNREACHABLE();
+ }
+}
+
void FlowGraphCompiler::LoadBSSEntry(BSS::Relocation relocation,
Register dst,
Register tmp) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
index d99625c..381cf0b 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
@@ -899,9 +899,9 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
+ ASSERT(destination.container_type().SizeInBytes() <= 4);
if (!sign_or_zero_extend) {
- ASSERT(dst_size == 4);
- __ movl(dst_reg, src_reg);
+ __ MoveRegister(dst_reg, src_reg);
} else {
switch (src_type.AsPrimitive().representation()) {
case compiler::ffi::kInt8: // Sign extend operand.
@@ -910,12 +910,22 @@
case compiler::ffi::kInt16:
__ ExtendValue(dst_reg, src_reg, compiler::kTwoBytes);
return;
+ case compiler::ffi::kInt24:
+ __ MoveRegister(dst_reg, src_reg);
+ __ shll(dst_reg, compiler::Immediate(8));
+ __ sarl(dst_reg, compiler::Immediate(8));
+ return;
case compiler::ffi::kUint8: // Zero extend operand.
__ ExtendValue(dst_reg, src_reg, compiler::kUnsignedByte);
return;
case compiler::ffi::kUint16:
__ ExtendValue(dst_reg, src_reg, compiler::kUnsignedTwoBytes);
return;
+ case compiler::ffi::kUint24:
+ __ MoveRegister(dst_reg, src_reg);
+ __ shll(dst_reg, compiler::Immediate(8));
+ __ shrl(dst_reg, compiler::Immediate(8));
+ return;
default:
// 32 to 64 bit is covered in IL by Representation conversions.
UNIMPLEMENTED();
@@ -931,7 +941,7 @@
ASSERT(!sign_or_zero_extend);
const auto& dst = destination.AsStack();
const auto dst_addr = NativeLocationToStackSlotAddress(dst);
- switch (dst_size) {
+ switch (destination.container_type().SizeInBytes()) {
case 4:
__ movl(dst_addr, src_reg);
return;
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc b/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc
index 877e6db..13f727b 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_riscv.cc
@@ -904,6 +904,8 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
+ ASSERT(destination.container_type().SizeInBytes() <=
+ compiler::target::kWordSize);
if (!sign_or_zero_extend) {
#if XLEN == 32
__ MoveRegister(dst_reg, src_reg);
@@ -945,6 +947,24 @@
__ addiw(dst_reg, src_reg, 0);
return;
#endif
+ case compiler::ffi::kInt24:
+#if XLEN >= 64
+ case compiler::ffi::kInt40:
+ case compiler::ffi::kInt48:
+ case compiler::ffi::kInt56:
+#endif
+ __ slli(dst_reg, src_reg, XLEN - src_size * kBitsPerByte);
+ __ srai(dst_reg, dst_reg, XLEN - src_size * kBitsPerByte);
+ return;
+ case compiler::ffi::kUint24:
+#if XLEN >= 64
+ case compiler::ffi::kUint40:
+ case compiler::ffi::kUint48:
+ case compiler::ffi::kUint56:
+#endif
+ __ slli(dst_reg, src_reg, XLEN - src_size * kBitsPerByte);
+ __ srli(dst_reg, dst_reg, XLEN - src_size * kBitsPerByte);
+ return;
default:
UNREACHABLE();
}
@@ -973,7 +993,8 @@
ASSERT(destination.IsStack());
const auto& dst = destination.AsStack();
ASSERT(!sign_or_zero_extend);
- auto const op_size = BytesToOperandSize(dst_size);
+ auto const op_size =
+ BytesToOperandSize(destination.container_type().SizeInBytes());
__ StoreToOffset(src.reg_at(0), dst.base_register(),
dst.offset_in_bytes(), op_size);
}
@@ -1030,9 +1051,8 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
- ASSERT(!sign_or_zero_extend);
- __ LoadFromOffset(dst_reg, src.base_register(), src.offset_in_bytes(),
- BytesToOperandSize(dst_size));
+ EmitNativeLoad(dst_reg, src.base_register(), src.offset_in_bytes(),
+ src_type.AsPrimitive().representation());
} else if (destination.IsFpuRegisters()) {
ASSERT(src_type.Equals(dst_type));
ASSERT(src_type.IsFloat());
@@ -1056,6 +1076,117 @@
}
}
+void FlowGraphCompiler::EmitNativeLoad(Register dst,
+ Register base,
+ intptr_t offset,
+ compiler::ffi::PrimitiveType type) {
+ switch (type) {
+ case compiler::ffi::kInt8:
+ __ lb(dst, compiler::Address(base, offset));
+ return;
+ case compiler::ffi::kUint8:
+ __ lbu(dst, compiler::Address(base, offset));
+ return;
+ case compiler::ffi::kInt16:
+ __ lh(dst, compiler::Address(base, offset));
+ return;
+ case compiler::ffi::kUint16:
+ __ lhu(dst, compiler::Address(base, offset));
+ return;
+ case compiler::ffi::kInt32:
+ __ lw(dst, compiler::Address(base, offset));
+ return;
+ case compiler::ffi::kUint32:
+ case compiler::ffi::kFloat:
+#if XLEN == 32
+ __ lw(dst, compiler::Address(base, offset));
+#else
+ __ lwu(dst, compiler::Address(base, offset));
+#endif
+ return;
+#if XLEN >= 64
+ case compiler::ffi::kInt64:
+ case compiler::ffi::kUint64:
+ case compiler::ffi::kDouble:
+ __ ld(dst, compiler::Address(base, offset));
+ return;
+#endif
+ default:
+ break;
+ }
+
+ Register tmp = kNoRegister;
+ if (dst != T1 && base != T1) tmp = T1;
+ if (dst != T2 && base != T2) tmp = T2;
+ if (dst != T3 && base != T3) tmp = T3;
+ ASSERT(tmp != kNoRegister);
+ if (base == SP) offset += compiler::target::kWordSize;
+ __ PushRegister(tmp);
+
+ switch (type) {
+ case compiler::ffi::kInt24:
+ __ lhu(dst, compiler::Address(base, offset));
+ __ lb(tmp, compiler::Address(base, offset + 2));
+ __ slli(tmp, tmp, 16);
+ __ or_(dst, dst, tmp);
+ break;
+ case compiler::ffi::kUint24:
+ __ lhu(dst, compiler::Address(base, offset));
+ __ lbu(tmp, compiler::Address(base, offset + 2));
+ __ slli(tmp, tmp, 16);
+ __ or_(dst, dst, tmp);
+ break;
+#if XLEN >= 64
+ case compiler::ffi::kInt40:
+ __ lwu(dst, compiler::Address(base, offset));
+ __ lb(tmp, compiler::Address(base, offset + 4));
+ __ slli(tmp, tmp, 32);
+ __ or_(dst, dst, tmp);
+ break;
+ case compiler::ffi::kUint40:
+ __ lwu(dst, compiler::Address(base, offset));
+ __ lbu(tmp, compiler::Address(base, offset + 4));
+ __ slli(tmp, tmp, 32);
+ __ or_(dst, dst, tmp);
+ break;
+ case compiler::ffi::kInt48:
+ __ lwu(dst, compiler::Address(base, offset));
+ __ lh(tmp, compiler::Address(base, offset + 4));
+ __ slli(tmp, tmp, 32);
+ __ or_(dst, dst, tmp);
+ break;
+ case compiler::ffi::kUint48:
+ __ lwu(dst, compiler::Address(base, offset));
+ __ lhu(tmp, compiler::Address(base, offset + 4));
+ __ slli(tmp, tmp, 32);
+ __ or_(dst, dst, tmp);
+ break;
+ case compiler::ffi::kInt56:
+ __ lwu(dst, compiler::Address(base, offset));
+ __ lhu(tmp, compiler::Address(base, offset + 4));
+ __ slli(tmp, tmp, 32);
+ __ or_(dst, dst, tmp);
+ __ lb(tmp, compiler::Address(base, offset + 6));
+ __ slli(tmp, tmp, 48);
+ __ or_(dst, dst, tmp);
+ break;
+ case compiler::ffi::kUint56:
+ __ lwu(dst, compiler::Address(base, offset));
+ __ lhu(tmp, compiler::Address(base, offset + 4));
+ __ slli(tmp, tmp, 32);
+ __ or_(dst, dst, tmp);
+ __ lbu(tmp, compiler::Address(base, offset + 6));
+ __ slli(tmp, tmp, 48);
+ __ or_(dst, dst, tmp);
+ break;
+#endif
+ default:
+ UNREACHABLE();
+ }
+
+ __ PopRegister(tmp);
+}
+
void FlowGraphCompiler::LoadBSSEntry(BSS::Relocation relocation,
Register dst,
Register tmp) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
index 782c8ba..12ea6c6 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
@@ -863,17 +863,10 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
+ ASSERT(destination.container_type().SizeInBytes() <= 8);
if (!sign_or_zero_extend) {
- switch (dst_size) {
- case 8:
- __ movq(dst_reg, src_reg);
- return;
- case 4:
- __ movl(dst_reg, src_reg);
- return;
- default:
- UNIMPLEMENTED();
- }
+ __ MoveRegister(dst_reg, src_reg);
+ return;
} else {
switch (src_type.AsPrimitive().representation()) {
case compiler::ffi::kInt8: // Sign extend operand.
@@ -882,15 +875,36 @@
case compiler::ffi::kInt16:
__ movsxw(dst_reg, src_reg);
return;
+ case compiler::ffi::kInt32:
+ __ movsxd(dst_reg, src_reg);
+ return;
+ case compiler::ffi::kInt24:
+ case compiler::ffi::kInt48:
+ case compiler::ffi::kInt40:
+ case compiler::ffi::kInt56:
+ __ MoveRegister(dst_reg, src_reg);
+ __ shlq(dst_reg, compiler::Immediate(64 - src_size * kBitsPerByte));
+ __ sarq(dst_reg, compiler::Immediate(64 - src_size * kBitsPerByte));
+ return;
case compiler::ffi::kUint8: // Zero extend operand.
__ movzxb(dst_reg, src_reg);
return;
case compiler::ffi::kUint16:
__ movzxw(dst_reg, src_reg);
return;
+ case compiler::ffi::kUint32:
+ __ movl(dst_reg, src_reg);
+ return;
+ case compiler::ffi::kUint24:
+ case compiler::ffi::kUint40:
+ case compiler::ffi::kUint48:
+ case compiler::ffi::kUint56:
+ __ MoveRegister(dst_reg, src_reg);
+ __ shlq(dst_reg, compiler::Immediate(64 - src_size * kBitsPerByte));
+ __ shrq(dst_reg, compiler::Immediate(64 - src_size * kBitsPerByte));
+ return;
default:
- // 32 to 64 bit is covered in IL by Representation conversions.
- UNIMPLEMENTED();
+ UNREACHABLE();
}
}
@@ -913,7 +927,7 @@
const auto& dst = destination.AsStack();
const auto dst_addr = NativeLocationToStackSlotAddress(dst);
ASSERT(!sign_or_zero_extend);
- switch (dst_size) {
+ switch (destination.container_type().SizeInBytes()) {
case 8:
__ movq(dst_addr, src_reg);
return;
@@ -983,37 +997,8 @@
const auto& dst = destination.AsRegisters();
ASSERT(dst.num_regs() == 1);
const auto dst_reg = dst.reg_at(0);
- if (!sign_or_zero_extend) {
- switch (dst_size) {
- case 8:
- __ movq(dst_reg, src_addr);
- return;
- case 4:
- __ movl(dst_reg, src_addr);
- return;
- default:
- UNIMPLEMENTED();
- }
- } else {
- switch (src_type.AsPrimitive().representation()) {
- case compiler::ffi::kInt8: // Sign extend operand.
- __ movsxb(dst_reg, src_addr);
- return;
- case compiler::ffi::kInt16:
- __ movsxw(dst_reg, src_addr);
- return;
- case compiler::ffi::kUint8: // Zero extend operand.
- __ movzxb(dst_reg, src_addr);
- return;
- case compiler::ffi::kUint16:
- __ movzxw(dst_reg, src_addr);
- return;
- default:
- // 32 to 64 bit is covered in IL by Representation conversions.
- UNIMPLEMENTED();
- }
- }
-
+ EmitNativeLoad(dst_reg, src.base_register(), src.offset_in_bytes(),
+ src_type.AsPrimitive().representation());
} else if (destination.IsFpuRegisters()) {
ASSERT(src_type.Equals(dst_type));
ASSERT(src_type.IsFloat());
@@ -1036,6 +1021,95 @@
}
}
+void FlowGraphCompiler::EmitNativeLoad(Register dst,
+ Register base,
+ intptr_t offset,
+ compiler::ffi::PrimitiveType type) {
+ switch (type) {
+ case compiler::ffi::kInt8:
+ __ LoadFromOffset(dst, base, offset, compiler::kByte);
+ break;
+ case compiler::ffi::kUint8:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedByte);
+ break;
+ case compiler::ffi::kInt16:
+ __ LoadFromOffset(dst, base, offset, compiler::kTwoBytes);
+ break;
+ case compiler::ffi::kUint16:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ break;
+ case compiler::ffi::kInt32:
+ __ LoadFromOffset(dst, base, offset, compiler::kFourBytes);
+ break;
+ case compiler::ffi::kUint32:
+ case compiler::ffi::kFloat:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ break;
+ case compiler::ffi::kInt64:
+ case compiler::ffi::kUint64:
+ case compiler::ffi::kDouble:
+ __ LoadFromOffset(dst, base, offset, compiler::kEightBytes);
+ break;
+
+ case compiler::ffi::kInt24:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ __ LoadFromOffset(TMP, base, offset + 2, compiler::kByte);
+ __ shlq(TMP, compiler::Immediate(16));
+ __ orq(dst, TMP);
+ break;
+ case compiler::ffi::kUint24:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedTwoBytes);
+ __ LoadFromOffset(TMP, base, offset + 2, compiler::kUnsignedByte);
+ __ shlq(TMP, compiler::Immediate(16));
+ __ orq(dst, TMP);
+ break;
+ case compiler::ffi::kInt40:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kByte);
+ __ shlq(TMP, compiler::Immediate(32));
+ __ orq(dst, TMP);
+ break;
+ case compiler::ffi::kUint40:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedByte);
+ __ shlq(TMP, compiler::Immediate(32));
+ __ orq(dst, TMP);
+ break;
+ case compiler::ffi::kInt48:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kTwoBytes);
+ __ shlq(TMP, compiler::Immediate(32));
+ __ orq(dst, TMP);
+ break;
+ case compiler::ffi::kUint48:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedTwoBytes);
+ __ shlq(TMP, compiler::Immediate(32));
+ __ orq(dst, TMP);
+ break;
+ case compiler::ffi::kInt56:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedTwoBytes);
+ __ shlq(TMP, compiler::Immediate(32));
+ __ orq(dst, TMP);
+ __ LoadFromOffset(TMP, base, offset + 6, compiler::kByte);
+ __ shlq(TMP, compiler::Immediate(48));
+ __ orq(dst, TMP);
+ break;
+ case compiler::ffi::kUint56:
+ __ LoadFromOffset(dst, base, offset, compiler::kUnsignedFourBytes);
+ __ LoadFromOffset(TMP, base, offset + 4, compiler::kUnsignedTwoBytes);
+ __ shlq(TMP, compiler::Immediate(32));
+ __ orq(dst, TMP);
+ __ LoadFromOffset(TMP, base, offset + 6, compiler::kUnsignedByte);
+ __ shlq(TMP, compiler::Immediate(48));
+ __ orq(dst, TMP);
+ break;
+ default:
+ UNREACHABLE();
+ }
+}
+
void FlowGraphCompiler::LoadBSSEntry(BSS::Relocation relocation,
Register dst,
Register tmp) {
diff --git a/runtime/vm/compiler/ffi/marshaller.cc b/runtime/vm/compiler/ffi/marshaller.cc
index a05f0ae..8b40aa0 100644
--- a/runtime/vm/compiler/ffi/marshaller.cc
+++ b/runtime/vm/compiler/ffi/marshaller.cc
@@ -321,8 +321,7 @@
if (location.IsStack()) {
// Split the struct in architecture size chunks.
- return compiler::target::kWordSize == 8 ? Representation::kUnboxedInt64
- : Representation::kUnboxedInt32;
+ return kUnboxedWord;
}
if (location.IsMultiple()) {
diff --git a/runtime/vm/compiler/ffi/native_calling_convention.cc b/runtime/vm/compiler/ffi/native_calling_convention.cc
index 15615995..2db21f7 100644
--- a/runtime/vm/compiler/ffi/native_calling_convention.cc
+++ b/runtime/vm/compiler/ffi/native_calling_convention.cc
@@ -76,6 +76,30 @@
const PrimitiveType kFfiIntPtr =
compiler::target::kWordSize == 8 ? kInt64 : kUint32;
+static PrimitiveType TypeForSize(intptr_t size) {
+ switch (size) {
+ case 8:
+ return kUint64;
+ case 7:
+ return kUint56;
+ case 6:
+ return kUint48;
+ case 5:
+ return kUint40;
+ case 4:
+ return kUint32;
+ case 3:
+ return kUint24;
+ case 2:
+ return kUint16;
+ case 1:
+ return kUint8;
+ default:
+ UNREACHABLE();
+ return kVoid;
+ }
+}
+
// Represents the state of a stack frame going into a call, between allocations
// of argument locations.
class ArgumentAllocator : public ValueObject {
@@ -276,9 +300,13 @@
multiple_locations.Add(new (zone_) NativeFpuRegistersLocation(
type, type, kQuadFpuReg, reg_index));
} else {
- const auto& type = *new (zone_) NativePrimitiveType(kInt64);
+ const auto& payload_type =
+ *new (zone_) NativePrimitiveType(TypeForSize(Utils::Minimum(
+ size - offset, compiler::target::kWordSize)));
+ const auto& container_type = *new (zone_) NativePrimitiveType(
+ TypeForSize(compiler::target::kWordSize));
multiple_locations.Add(new (zone_) NativeRegistersLocation(
- zone_, type, type, AllocateCpuRegister()));
+ zone_, payload_type, container_type, AllocateCpuRegister()));
}
}
return *new (zone_)
@@ -365,7 +393,7 @@
BlockAllFpuRegisters();
return AllocateStack(payload_type);
}
- } else {
+ } else if (payload_type.AlignmentInBytesStack() == 8) {
const intptr_t chunk_size = payload_type.AlignmentInBytesStack();
ASSERT(chunk_size == 4 || chunk_size == 8);
const intptr_t size_rounded =
@@ -392,6 +420,8 @@
}
return *new (zone_)
MultipleNativeLocations(compound_type, multiple_locations);
+ } else {
+ return AllocateCompoundAsMultiple(compound_type);
}
}
#endif // defined(TARGET_ARCH_ARM)
@@ -448,16 +478,7 @@
}
#endif
- const auto& chunk_type = *new (zone_) NativePrimitiveType(kInt64);
-
- NativeLocations& multiple_locations =
- *new (zone_) NativeLocations(zone_, num_chunks);
- for (int i = 0; i < num_chunks; i++) {
- const auto& allocated_chunk = &AllocateArgument(chunk_type, is_vararg);
- multiple_locations.Add(allocated_chunk);
- }
- return *new (zone_)
- MultipleNativeLocations(compound_type, multiple_locations);
+ return AllocateCompoundAsMultiple(payload_type);
}
const auto& pointer_location =
@@ -518,39 +539,59 @@
}
// 2.1. Integer Calling Convention.
- const auto& pointer_type = *new (zone_) NativePrimitiveType(kFfiIntPtr);
- const intptr_t size = compound_type.SizeInBytes();
-
// If total size is <= XLEN, passed like an XLEN scalar: use a register if
// available or pass by value on the stack.
- if (size <= target::kWordSize) {
- NativeLocations& multiple_locations =
- *new (zone_) NativeLocations(zone_, 1);
- multiple_locations.Add(&AllocateArgument(pointer_type));
- return *new (zone_)
- MultipleNativeLocations(compound_type, multiple_locations);
- }
-
// If total size is <= 2*XLEN, passed like two XLEN scalars: use registers
// if available or pass by value on the stack. If only one register is
// available, pass the low part by register and the high part on the
// stack.
- if (size <= 2 * target::kWordSize) {
- NativeLocations& multiple_locations =
- *new (zone_) NativeLocations(zone_, 2);
- multiple_locations.Add(&AllocateArgument(pointer_type));
- multiple_locations.Add(&AllocateArgument(pointer_type));
- return *new (zone_)
- MultipleNativeLocations(compound_type, multiple_locations);
+ if (compound_type.SizeInBytes() <= 2 * target::kWordSize) {
+ return AllocateCompoundAsMultiple(compound_type);
}
// Otherwise, passed by reference.
+ const auto& pointer_type = *new (zone_) NativePrimitiveType(kFfiIntPtr);
const auto& pointer_location = AllocateArgument(pointer_type);
return *new (zone_)
PointerToMemoryLocation(pointer_location, compound_type);
}
#endif
+ // Allocate in word-sized chunks, with the container as a full word-sized
+ // register or stack slot and the payload constrained to the struct's size.
+ //
+ // Note this describes the location at call. Consumes of this location, such
+ // as FfiCallConvertCompoundArgumentToNative or EmitReturnMoves, often assume
+ // the location of the source compound in the heap corresponds to this
+ // location with just a change in base register. This is often true, except
+ // some ABIs assume zero extension of the last chunk, so the stack location at
+ // call is bigger than the location in the heap. Here we set the container
+ // size to reflect that zero-extended stack slot and rely on loads during
+ // moves opting to use the payload size instead of the container size to stay
+ // in-bounds.
+ const NativeLocation& AllocateCompoundAsMultiple(
+ const NativeCompoundType& compound_type) {
+ const intptr_t chunk_size = compiler::target::kWordSize;
+ const intptr_t num_chunks =
+ Utils::RoundUp(compound_type.SizeInBytes(), chunk_size) / chunk_size;
+ const NativeType& container_type =
+ *new (zone_) NativePrimitiveType(TypeForSize(chunk_size));
+ NativeLocations& locations =
+ *new (zone_) NativeLocations(zone_, num_chunks);
+ intptr_t size_remaining = compound_type.SizeInBytes();
+ while (size_remaining > 0) {
+ const auto& chunk = AllocateArgument(container_type);
+
+ const intptr_t size = Utils::Minimum(size_remaining, chunk_size);
+ const NativeType& payload_type =
+ *new (zone_) NativePrimitiveType(TypeForSize(size));
+ locations.Add(
+ &chunk.WithOtherNativeType(zone_, payload_type, container_type));
+ size_remaining -= size;
+ }
+ return *new (zone_) MultipleNativeLocations(compound_type, locations);
+ }
+
static FpuRegisterKind FpuRegKind(const NativeType& payload_type) {
#if defined(TARGET_ARCH_ARM)
return FpuRegisterKindFromSize(payload_type.SizeInBytes());
@@ -744,7 +785,6 @@
intptr_t used_xmm_regs = 0;
const auto& double_type = *new (zone) NativePrimitiveType(kDouble);
- const auto& int64_type = *new (zone) NativePrimitiveType(kInt64);
const bool first_half_in_xmm = payload_type.ContainsOnlyFloats(
Range::StartAndEnd(0, Utils::Minimum<intptr_t>(size, 8)));
@@ -754,8 +794,12 @@
CallingConventions::kReturnFpuReg));
used_xmm_regs++;
} else {
+ const auto& payload_type = *new (zone) NativePrimitiveType(
+ TypeForSize(Utils::Minimum(size, compiler::target::kWordSize)));
+ const auto& container_type = *new (zone) NativePrimitiveType(
+ TypeForSize(compiler::target::kWordSize));
multiple_locations.Add(new (zone) NativeRegistersLocation(
- zone, int64_type, int64_type, CallingConventions::kReturnReg));
+ zone, payload_type, container_type, CallingConventions::kReturnReg));
used_regs++;
}
if (size > 8) {
@@ -772,8 +816,12 @@
const Register reg = used_regs == 0
? CallingConventions::kReturnReg
: CallingConventions::kSecondReturnReg;
+ const auto& payload_type = *new (zone) NativePrimitiveType(
+ TypeForSize(Utils::Minimum(size - 8, compiler::target::kWordSize)));
+ const auto& container_type = *new (zone) NativePrimitiveType(
+ TypeForSize(compiler::target::kWordSize));
multiple_locations.Add(new (zone) NativeRegistersLocation(
- zone, int64_type, int64_type, reg));
+ zone, payload_type, container_type, reg));
used_regs++;
}
}
diff --git a/runtime/vm/compiler/ffi/native_type.cc b/runtime/vm/compiler/ffi/native_type.cc
index 3e6d9af..9401423 100644
--- a/runtime/vm/compiler/ffi/native_type.cc
+++ b/runtime/vm/compiler/ffi/native_type.cc
@@ -69,8 +69,16 @@
case kUint8:
case kInt16:
case kUint16:
+ case kInt24:
+ case kUint24:
case kInt32:
case kUint32:
+ case kInt40:
+ case kUint40:
+ case kInt48:
+ case kUint48:
+ case kInt56:
+ case kUint56:
case kInt64:
case kUint64:
return true;
@@ -93,7 +101,11 @@
switch (representation_) {
case kInt8:
case kInt16:
+ case kInt24:
case kInt32:
+ case kInt40:
+ case kInt48:
+ case kInt56:
case kInt64:
case kFloat:
case kDouble:
@@ -101,7 +113,11 @@
return true;
case kUint8:
case kUint16:
+ case kUint24:
case kUint32:
+ case kUint40:
+ case kUint48:
+ case kUint56:
case kUint64:
default:
return false;
@@ -120,6 +136,14 @@
4, // kFloat,
8, // kDouble,
4, // kHalfDouble
+ 3, // kInt24,
+ 3, // kUint24,
+ 5, // kInt40,
+ 5, // kUint40,
+ 6, // kInt48,
+ 6, // kUint48,
+ 7, // kInt56,
+ 7, // kUint56,
0, // kVoid,
};
@@ -260,6 +284,14 @@
case kUint8:
case kInt16:
case kUint16:
+ case kInt24:
+ case kUint24:
+ case kInt40:
+ case kUint40:
+ case kInt48:
+ case kUint48:
+ case kInt56:
+ case kUint56:
case kHalfDouble:
return false;
case kInt32:
@@ -648,6 +680,22 @@
return "double";
case kHalfDouble:
return "half-double";
+ case kInt24:
+ return "int24";
+ case kUint24:
+ return "uint24";
+ case kInt40:
+ return "int40";
+ case kUint40:
+ return "uint40";
+ case kInt48:
+ return "int48";
+ case kUint48:
+ return "uint48";
+ case kInt56:
+ return "int56";
+ case kUint56:
+ return "uint56";
case kVoid:
return "void";
default:
@@ -1015,6 +1063,30 @@
return ContainsHomogeneousFloatsInternal(this->members());
}
+#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
+Representation NativeType::AsRepresentationOverApprox(Zone* zone_) const {
+ if (IsPrimitive()) {
+ switch (AsPrimitive().representation()) {
+ case kInt24:
+ return kUnboxedInt32;
+ case kUint24:
+ return kUnboxedUint32;
+ case kInt40:
+ case kUint40:
+ case kInt48:
+ case kUint48:
+ case kInt56:
+ case kUint56:
+ return kUnboxedInt64;
+ default:
+ break;
+ }
+ }
+ const auto& widened = WidenTo4Bytes(zone_);
+ return widened.AsRepresentation();
+}
+#endif // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
+
const NativeType& NativeType::WidenTo4Bytes(Zone* zone) const {
if (IsInt() && SizeInBytes() <= 2) {
if (IsSigned()) {
diff --git a/runtime/vm/compiler/ffi/native_type.h b/runtime/vm/compiler/ffi/native_type.h
index e484b0f..c5b8bae 100644
--- a/runtime/vm/compiler/ffi/native_type.h
+++ b/runtime/vm/compiler/ffi/native_type.h
@@ -120,10 +120,7 @@
virtual Representation AsRepresentation() const { UNREACHABLE_THIS(); }
// Unboxed Representation, over approximates if needed.
- Representation AsRepresentationOverApprox(Zone* zone_) const {
- const auto& widened = WidenTo4Bytes(zone_);
- return widened.AsRepresentation();
- }
+ Representation AsRepresentationOverApprox(Zone* zone_) const;
#endif // !defined(DART_PRECOMPILED_RUNTIME) && !defined(FFI_UNIT_TESTS)
virtual bool Equals(const NativeType& other) const { UNREACHABLE_THIS(); }
@@ -175,6 +172,14 @@
kFloat,
kDouble,
kHalfDouble, // When doubles are split over two 32 bit locations.
+ kInt24,
+ kUint24,
+ kInt40,
+ kUint40,
+ kInt48,
+ kUint48,
+ kInt56,
+ kUint56,
kVoid,
// TODO(37470): Add packed data structures.
};
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_android.expect
index 9245d0d..acfe18d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_android.expect
@@ -1,3 +1,3 @@
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_fuchsia.expect
index 9245d0d..acfe18d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_fuchsia.expect
@@ -1,3 +1,3 @@
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_ios.expect
index 9245d0d..acfe18d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_ios.expect
@@ -1,3 +1,3 @@
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_linux.expect
index 9245d0d..acfe18d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_linux.expect
@@ -1,3 +1,3 @@
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_macos.expect
index 9245d0d..acfe18d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_macos.expect
@@ -1,3 +1,3 @@
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_win.expect
index 9245d0d..acfe18d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/arm64_win.expect
@@ -1,3 +1,3 @@
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/riscv64_linux.expect
index ea09b9b..d658e5b 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/riscv64_linux.expect
@@ -1,3 +1,3 @@
=>
-M(a0 int64) Struct(size: 8)
+M(a0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_fuchsia.expect
index 49ae1fd..3d5f8d4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_fuchsia.expect
@@ -1,3 +1,3 @@
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_ios.expect
index 49ae1fd..3d5f8d4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_ios.expect
@@ -1,3 +1,3 @@
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_linux.expect
index 49ae1fd..3d5f8d4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_linux.expect
@@ -1,3 +1,3 @@
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_macos.expect
index 49ae1fd..3d5f8d4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/regress46127/x64_macos.expect
@@ -1,3 +1,3 @@
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_android.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_android.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_fuchsia.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_fuchsia.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_ios.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_ios.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_linux.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_linux.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_macos.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_macos.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_win.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm64_win.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_android.expect
index 8e13dd5..30f16ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_android.expect
@@ -1,6 +1,6 @@
r0 int32
r1 int32
r2 int32
-M(r3 int32, S+0 int32) Struct(size: 6)
+M(r3 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
r0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_ios.expect
index 8e13dd5..30f16ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_ios.expect
@@ -1,6 +1,6 @@
r0 int32
r1 int32
r2 int32
-M(r3 int32, S+0 int32) Struct(size: 6)
+M(r3 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
r0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_linux.expect
index 8e13dd5..30f16ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/arm_linux.expect
@@ -1,6 +1,6 @@
r0 int32
r1 int32
r2 int32
-M(r3 int32, S+0 int32) Struct(size: 6)
+M(r3 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
r0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv32_linux.expect
index 540bf12..7cfe9f4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv32_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv32_linux.expect
@@ -5,6 +5,6 @@
t4 int32
t5 int32
a6 int32
-M(a7 uint32, S+0 uint32) Struct(size: 6)
+M(a7 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
a0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv64_linux.expect
index 33930e4..7421b1b 100644
--- a/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/stradle_last_register/riscv64_linux.expect
@@ -5,6 +5,6 @@
t4 int64
t5 int64
a6 int64
-M(a7 int64, S+0 int64) Struct(size: 12)
+M(a7 uint64, S+0 uint64[uint32]) Struct(size: 12)
=>
a0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/arm_android.expect
index 3cd3492..689cccd 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/arm_android.expect
@@ -1,8 +1,8 @@
-M(r0 int32, r1 int32, r2 int32) Struct(size: 12)
-M(r3 int32, S+0 int32, S+4 int32) Struct(size: 12)
-M(S+8 int32, S+12 int32, S+16 int32) Struct(size: 12)
-M(S+20 int32, S+24 int32, S+28 int32) Struct(size: 12)
-M(S+32 int32, S+36 int32, S+40 int32) Struct(size: 12)
-M(S+44 int32, S+48 int32, S+52 int32) Struct(size: 12)
+M(r0 uint32, r1 uint32, r2 uint32) Struct(size: 12)
+M(r3 uint32, S+0 uint32, S+4 uint32) Struct(size: 12)
+M(S+8 uint32, S+12 uint32, S+16 uint32) Struct(size: 12)
+M(S+20 uint32, S+24 uint32, S+28 uint32) Struct(size: 12)
+M(S+32 uint32, S+36 uint32, S+40 uint32) Struct(size: 12)
+M(S+44 uint32, S+48 uint32, S+52 uint32) Struct(size: 12)
=>
(r0, r1) int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/riscv64_linux.expect
index 05ce4c9..9d6bcf9 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct12bytesFloatx6/riscv64_linux.expect
@@ -1,8 +1,8 @@
-M(a0 int64, a1 int64) Struct(size: 12)
-M(a2 int64, t3 int64) Struct(size: 12)
-M(t4 int64, t5 int64) Struct(size: 12)
-M(a6 int64, a7 int64) Struct(size: 12)
-M(S+0 int64, S+8 int64) Struct(size: 12)
-M(S+16 int64, S+24 int64) Struct(size: 12)
+M(a0 uint64, a1 uint64[uint32]) Struct(size: 12)
+M(a2 uint64, t3 uint64[uint32]) Struct(size: 12)
+M(t4 uint64, t5 uint64[uint32]) Struct(size: 12)
+M(a6 uint64, a7 uint64[uint32]) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
+M(S+16 uint64, S+24 uint64[uint32]) Struct(size: 12)
=>
a0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_android.expect
index cf17311..7221f16 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/arm_android.expect
@@ -1,15 +1,15 @@
-M(r1 int32, r2 int32, r3 int32, S+0 int32) Struct(size: 16)
+M(r1 uint32, r2 uint32, r3 uint32, S+0 uint32) Struct(size: 16)
S+4 float
-M(S+8 int32, S+12 int32, S+16 int32, S+20 int32) Struct(size: 16)
-M(S+24 int32, S+28 int32, S+32 int32, S+36 int32) Struct(size: 16)
-M(S+40 int32, S+44 int32, S+48 int32, S+52 int32) Struct(size: 16)
-M(S+56 int32, S+60 int32, S+64 int32, S+68 int32) Struct(size: 16)
-M(S+72 int32, S+76 int32, S+80 int32, S+84 int32) Struct(size: 16)
-M(S+88 int32, S+92 int32, S+96 int32, S+100 int32) Struct(size: 16)
-M(S+104 int32, S+108 int32, S+112 int32, S+116 int32) Struct(size: 16)
-M(S+120 int32, S+124 int32, S+128 int32, S+132 int32) Struct(size: 16)
+M(S+8 uint32, S+12 uint32, S+16 uint32, S+20 uint32) Struct(size: 16)
+M(S+24 uint32, S+28 uint32, S+32 uint32, S+36 uint32) Struct(size: 16)
+M(S+40 uint32, S+44 uint32, S+48 uint32, S+52 uint32) Struct(size: 16)
+M(S+56 uint32, S+60 uint32, S+64 uint32, S+68 uint32) Struct(size: 16)
+M(S+72 uint32, S+76 uint32, S+80 uint32, S+84 uint32) Struct(size: 16)
+M(S+88 uint32, S+92 uint32, S+96 uint32, S+100 uint32) Struct(size: 16)
+M(S+104 uint32, S+108 uint32, S+112 uint32, S+116 uint32) Struct(size: 16)
+M(S+120 uint32, S+124 uint32, S+128 uint32, S+132 uint32) Struct(size: 16)
S+136 float
S+140 int32[int8]
-M(S+144 int32, S+148 int32, S+152 int32, S+156 int32) Struct(size: 16)
+M(S+144 uint32, S+148 uint32, S+152 uint32, S+156 uint32) Struct(size: 16)
=>
P(r0 uint32) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/riscv64_linux.expect
index 27da467..d62e409 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesHomogenousx10/riscv64_linux.expect
@@ -1,15 +1,15 @@
-M(a0 int64, a1 int64) Struct(size: 16)
+M(a0 uint64, a1 uint64) Struct(size: 16)
fa0 float
-M(a2 int64, t3 int64) Struct(size: 16)
-M(t4 int64, t5 int64) Struct(size: 16)
-M(a6 int64, a7 int64) Struct(size: 16)
-M(S+0 int64, S+8 int64) Struct(size: 16)
-M(S+16 int64, S+24 int64) Struct(size: 16)
-M(S+32 int64, S+40 int64) Struct(size: 16)
-M(S+48 int64, S+56 int64) Struct(size: 16)
-M(S+64 int64, S+72 int64) Struct(size: 16)
+M(a2 uint64, t3 uint64) Struct(size: 16)
+M(t4 uint64, t5 uint64) Struct(size: 16)
+M(a6 uint64, a7 uint64) Struct(size: 16)
+M(S+0 uint64, S+8 uint64) Struct(size: 16)
+M(S+16 uint64, S+24 uint64) Struct(size: 16)
+M(S+32 uint64, S+40 uint64) Struct(size: 16)
+M(S+48 uint64, S+56 uint64) Struct(size: 16)
+M(S+64 uint64, S+72 uint64) Struct(size: 16)
fa1 float
S+80 int8
-M(S+88 int64, S+96 int64) Struct(size: 16)
+M(S+88 uint64, S+96 uint64) Struct(size: 16)
=>
-M(a0 int64, a1 int64) Struct(size: 16)
+M(a0 uint64, a1 uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_fuchsia.expect
index 62ce615..f2c2536 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_fuchsia.expect
@@ -1,13 +1,13 @@
-M(xmm0 double, rdi int64) Struct(size: 16)
-M(xmm1 double, rsi int64) Struct(size: 16)
-M(xmm2 double, rdx int64) Struct(size: 16)
-M(xmm3 double, rcx int64) Struct(size: 16)
-M(xmm4 double, r8 int64) Struct(size: 16)
-M(xmm5 double, r9 int64) Struct(size: 16)
+M(xmm0 double, rdi uint64) Struct(size: 16)
+M(xmm1 double, rsi uint64) Struct(size: 16)
+M(xmm2 double, rdx uint64) Struct(size: 16)
+M(xmm3 double, rcx uint64) Struct(size: 16)
+M(xmm4 double, r8 uint64) Struct(size: 16)
+M(xmm5 double, r9 uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_ios.expect
index 62ce615..f2c2536 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_ios.expect
@@ -1,13 +1,13 @@
-M(xmm0 double, rdi int64) Struct(size: 16)
-M(xmm1 double, rsi int64) Struct(size: 16)
-M(xmm2 double, rdx int64) Struct(size: 16)
-M(xmm3 double, rcx int64) Struct(size: 16)
-M(xmm4 double, r8 int64) Struct(size: 16)
-M(xmm5 double, r9 int64) Struct(size: 16)
+M(xmm0 double, rdi uint64) Struct(size: 16)
+M(xmm1 double, rsi uint64) Struct(size: 16)
+M(xmm2 double, rdx uint64) Struct(size: 16)
+M(xmm3 double, rcx uint64) Struct(size: 16)
+M(xmm4 double, r8 uint64) Struct(size: 16)
+M(xmm5 double, r9 uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_linux.expect
index 62ce615..f2c2536 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_linux.expect
@@ -1,13 +1,13 @@
-M(xmm0 double, rdi int64) Struct(size: 16)
-M(xmm1 double, rsi int64) Struct(size: 16)
-M(xmm2 double, rdx int64) Struct(size: 16)
-M(xmm3 double, rcx int64) Struct(size: 16)
-M(xmm4 double, r8 int64) Struct(size: 16)
-M(xmm5 double, r9 int64) Struct(size: 16)
+M(xmm0 double, rdi uint64) Struct(size: 16)
+M(xmm1 double, rsi uint64) Struct(size: 16)
+M(xmm2 double, rdx uint64) Struct(size: 16)
+M(xmm3 double, rcx uint64) Struct(size: 16)
+M(xmm4 double, r8 uint64) Struct(size: 16)
+M(xmm5 double, r9 uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_macos.expect
index 62ce615..f2c2536 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10/x64_macos.expect
@@ -1,13 +1,13 @@
-M(xmm0 double, rdi int64) Struct(size: 16)
-M(xmm1 double, rsi int64) Struct(size: 16)
-M(xmm2 double, rdx int64) Struct(size: 16)
-M(xmm3 double, rcx int64) Struct(size: 16)
-M(xmm4 double, r8 int64) Struct(size: 16)
-M(xmm5 double, r9 int64) Struct(size: 16)
+M(xmm0 double, rdi uint64) Struct(size: 16)
+M(xmm1 double, rsi uint64) Struct(size: 16)
+M(xmm2 double, rdx uint64) Struct(size: 16)
+M(xmm3 double, rcx uint64) Struct(size: 16)
+M(xmm4 double, r8 uint64) Struct(size: 16)
+M(xmm5 double, r9 uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_fuchsia.expect
index 71af233..0e85840 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_fuchsia.expect
@@ -2,10 +2,10 @@
xmm1 float
xmm2 float
xmm3 float
-M(xmm4 double, rdi int64) Struct(size: 16)
-M(xmm5 double, rsi int64) Struct(size: 16)
-M(xmm6 double, rdx int64) Struct(size: 16)
-M(xmm7 double, rcx int64) Struct(size: 16)
+M(xmm4 double, rdi uint64) Struct(size: 16)
+M(xmm5 double, rsi uint64) Struct(size: 16)
+M(xmm6 double, rdx uint64) Struct(size: 16)
+M(xmm7 double, rcx uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
@@ -14,4 +14,4 @@
S+80 Struct(size: 16)
r8 int32
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_ios.expect
index 71af233..0e85840 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_ios.expect
@@ -2,10 +2,10 @@
xmm1 float
xmm2 float
xmm3 float
-M(xmm4 double, rdi int64) Struct(size: 16)
-M(xmm5 double, rsi int64) Struct(size: 16)
-M(xmm6 double, rdx int64) Struct(size: 16)
-M(xmm7 double, rcx int64) Struct(size: 16)
+M(xmm4 double, rdi uint64) Struct(size: 16)
+M(xmm5 double, rsi uint64) Struct(size: 16)
+M(xmm6 double, rdx uint64) Struct(size: 16)
+M(xmm7 double, rcx uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
@@ -14,4 +14,4 @@
S+80 Struct(size: 16)
r8 int32
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_linux.expect
index 71af233..0e85840 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_linux.expect
@@ -2,10 +2,10 @@
xmm1 float
xmm2 float
xmm3 float
-M(xmm4 double, rdi int64) Struct(size: 16)
-M(xmm5 double, rsi int64) Struct(size: 16)
-M(xmm6 double, rdx int64) Struct(size: 16)
-M(xmm7 double, rcx int64) Struct(size: 16)
+M(xmm4 double, rdi uint64) Struct(size: 16)
+M(xmm5 double, rsi uint64) Struct(size: 16)
+M(xmm6 double, rdx uint64) Struct(size: 16)
+M(xmm7 double, rcx uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
@@ -14,4 +14,4 @@
S+80 Struct(size: 16)
r8 int32
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_macos.expect
index 71af233..0e85840 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_2/x64_macos.expect
@@ -2,10 +2,10 @@
xmm1 float
xmm2 float
xmm3 float
-M(xmm4 double, rdi int64) Struct(size: 16)
-M(xmm5 double, rsi int64) Struct(size: 16)
-M(xmm6 double, rdx int64) Struct(size: 16)
-M(xmm7 double, rcx int64) Struct(size: 16)
+M(xmm4 double, rdi uint64) Struct(size: 16)
+M(xmm5 double, rsi uint64) Struct(size: 16)
+M(xmm6 double, rdx uint64) Struct(size: 16)
+M(xmm7 double, rcx uint64) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
@@ -14,4 +14,4 @@
S+80 Struct(size: 16)
r8 int32
=>
-M(xmm0 double, rax int64) Struct(size: 16)
+M(xmm0 double, rax uint64) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_fuchsia.expect
index e3119e6..667ea1d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_fuchsia.expect
@@ -1,13 +1,13 @@
-M(rdi int64, xmm0 double) Struct(size: 16)
-M(rsi int64, xmm1 double) Struct(size: 16)
-M(rdx int64, xmm2 double) Struct(size: 16)
-M(rcx int64, xmm3 double) Struct(size: 16)
-M(r8 int64, xmm4 double) Struct(size: 16)
-M(r9 int64, xmm5 double) Struct(size: 16)
+M(rdi uint64, xmm0 double) Struct(size: 16)
+M(rsi uint64, xmm1 double) Struct(size: 16)
+M(rdx uint64, xmm2 double) Struct(size: 16)
+M(rcx uint64, xmm3 double) Struct(size: 16)
+M(r8 uint64, xmm4 double) Struct(size: 16)
+M(r9 uint64, xmm5 double) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(rax int64, xmm0 double) Struct(size: 16)
+M(rax uint64, xmm0 double) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_ios.expect
index e3119e6..667ea1d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_ios.expect
@@ -1,13 +1,13 @@
-M(rdi int64, xmm0 double) Struct(size: 16)
-M(rsi int64, xmm1 double) Struct(size: 16)
-M(rdx int64, xmm2 double) Struct(size: 16)
-M(rcx int64, xmm3 double) Struct(size: 16)
-M(r8 int64, xmm4 double) Struct(size: 16)
-M(r9 int64, xmm5 double) Struct(size: 16)
+M(rdi uint64, xmm0 double) Struct(size: 16)
+M(rsi uint64, xmm1 double) Struct(size: 16)
+M(rdx uint64, xmm2 double) Struct(size: 16)
+M(rcx uint64, xmm3 double) Struct(size: 16)
+M(r8 uint64, xmm4 double) Struct(size: 16)
+M(r9 uint64, xmm5 double) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(rax int64, xmm0 double) Struct(size: 16)
+M(rax uint64, xmm0 double) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_linux.expect
index e3119e6..667ea1d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_linux.expect
@@ -1,13 +1,13 @@
-M(rdi int64, xmm0 double) Struct(size: 16)
-M(rsi int64, xmm1 double) Struct(size: 16)
-M(rdx int64, xmm2 double) Struct(size: 16)
-M(rcx int64, xmm3 double) Struct(size: 16)
-M(r8 int64, xmm4 double) Struct(size: 16)
-M(r9 int64, xmm5 double) Struct(size: 16)
+M(rdi uint64, xmm0 double) Struct(size: 16)
+M(rsi uint64, xmm1 double) Struct(size: 16)
+M(rdx uint64, xmm2 double) Struct(size: 16)
+M(rcx uint64, xmm3 double) Struct(size: 16)
+M(r8 uint64, xmm4 double) Struct(size: 16)
+M(r9 uint64, xmm5 double) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(rax int64, xmm0 double) Struct(size: 16)
+M(rax uint64, xmm0 double) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_macos.expect
index e3119e6..667ea1d 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct16bytesMixedx10_3/x64_macos.expect
@@ -1,13 +1,13 @@
-M(rdi int64, xmm0 double) Struct(size: 16)
-M(rsi int64, xmm1 double) Struct(size: 16)
-M(rdx int64, xmm2 double) Struct(size: 16)
-M(rcx int64, xmm3 double) Struct(size: 16)
-M(r8 int64, xmm4 double) Struct(size: 16)
-M(r9 int64, xmm5 double) Struct(size: 16)
+M(rdi uint64, xmm0 double) Struct(size: 16)
+M(rsi uint64, xmm1 double) Struct(size: 16)
+M(rdx uint64, xmm2 double) Struct(size: 16)
+M(rcx uint64, xmm3 double) Struct(size: 16)
+M(r8 uint64, xmm4 double) Struct(size: 16)
+M(r9 uint64, xmm5 double) Struct(size: 16)
S+0 Struct(size: 16)
S+16 Struct(size: 16)
S+32 Struct(size: 16)
S+48 Struct(size: 16)
xmm6 float
=>
-M(rax int64, xmm0 double) Struct(size: 16)
+M(rax uint64, xmm0 double) Struct(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_android.expect
index 0eb0d54..48c523a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_android.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 3)
-M(r1 int64) Struct(size: 3)
-M(r2 int64) Struct(size: 3)
-M(r3 int64) Struct(size: 3)
-M(r4 int64) Struct(size: 3)
-M(r5 int64) Struct(size: 3)
-M(r6 int64) Struct(size: 3)
-M(r7 int64) Struct(size: 3)
-M(S+0 int64) Struct(size: 3)
-M(S+8 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
+M(r1 uint64[uint24]) Struct(size: 3)
+M(r2 uint64[uint24]) Struct(size: 3)
+M(r3 uint64[uint24]) Struct(size: 3)
+M(r4 uint64[uint24]) Struct(size: 3)
+M(r5 uint64[uint24]) Struct(size: 3)
+M(r6 uint64[uint24]) Struct(size: 3)
+M(r7 uint64[uint24]) Struct(size: 3)
+M(S+0 uint64[uint24]) Struct(size: 3)
+M(S+8 uint64[uint24]) Struct(size: 3)
=>
-M(r0 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_fuchsia.expect
index 0eb0d54..48c523a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_fuchsia.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 3)
-M(r1 int64) Struct(size: 3)
-M(r2 int64) Struct(size: 3)
-M(r3 int64) Struct(size: 3)
-M(r4 int64) Struct(size: 3)
-M(r5 int64) Struct(size: 3)
-M(r6 int64) Struct(size: 3)
-M(r7 int64) Struct(size: 3)
-M(S+0 int64) Struct(size: 3)
-M(S+8 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
+M(r1 uint64[uint24]) Struct(size: 3)
+M(r2 uint64[uint24]) Struct(size: 3)
+M(r3 uint64[uint24]) Struct(size: 3)
+M(r4 uint64[uint24]) Struct(size: 3)
+M(r5 uint64[uint24]) Struct(size: 3)
+M(r6 uint64[uint24]) Struct(size: 3)
+M(r7 uint64[uint24]) Struct(size: 3)
+M(S+0 uint64[uint24]) Struct(size: 3)
+M(S+8 uint64[uint24]) Struct(size: 3)
=>
-M(r0 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_ios.expect
index 0eb0d54..48c523a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_ios.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 3)
-M(r1 int64) Struct(size: 3)
-M(r2 int64) Struct(size: 3)
-M(r3 int64) Struct(size: 3)
-M(r4 int64) Struct(size: 3)
-M(r5 int64) Struct(size: 3)
-M(r6 int64) Struct(size: 3)
-M(r7 int64) Struct(size: 3)
-M(S+0 int64) Struct(size: 3)
-M(S+8 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
+M(r1 uint64[uint24]) Struct(size: 3)
+M(r2 uint64[uint24]) Struct(size: 3)
+M(r3 uint64[uint24]) Struct(size: 3)
+M(r4 uint64[uint24]) Struct(size: 3)
+M(r5 uint64[uint24]) Struct(size: 3)
+M(r6 uint64[uint24]) Struct(size: 3)
+M(r7 uint64[uint24]) Struct(size: 3)
+M(S+0 uint64[uint24]) Struct(size: 3)
+M(S+8 uint64[uint24]) Struct(size: 3)
=>
-M(r0 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_linux.expect
index 0eb0d54..48c523a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_linux.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 3)
-M(r1 int64) Struct(size: 3)
-M(r2 int64) Struct(size: 3)
-M(r3 int64) Struct(size: 3)
-M(r4 int64) Struct(size: 3)
-M(r5 int64) Struct(size: 3)
-M(r6 int64) Struct(size: 3)
-M(r7 int64) Struct(size: 3)
-M(S+0 int64) Struct(size: 3)
-M(S+8 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
+M(r1 uint64[uint24]) Struct(size: 3)
+M(r2 uint64[uint24]) Struct(size: 3)
+M(r3 uint64[uint24]) Struct(size: 3)
+M(r4 uint64[uint24]) Struct(size: 3)
+M(r5 uint64[uint24]) Struct(size: 3)
+M(r6 uint64[uint24]) Struct(size: 3)
+M(r7 uint64[uint24]) Struct(size: 3)
+M(S+0 uint64[uint24]) Struct(size: 3)
+M(S+8 uint64[uint24]) Struct(size: 3)
=>
-M(r0 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_macos.expect
index 0eb0d54..48c523a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_macos.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 3)
-M(r1 int64) Struct(size: 3)
-M(r2 int64) Struct(size: 3)
-M(r3 int64) Struct(size: 3)
-M(r4 int64) Struct(size: 3)
-M(r5 int64) Struct(size: 3)
-M(r6 int64) Struct(size: 3)
-M(r7 int64) Struct(size: 3)
-M(S+0 int64) Struct(size: 3)
-M(S+8 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
+M(r1 uint64[uint24]) Struct(size: 3)
+M(r2 uint64[uint24]) Struct(size: 3)
+M(r3 uint64[uint24]) Struct(size: 3)
+M(r4 uint64[uint24]) Struct(size: 3)
+M(r5 uint64[uint24]) Struct(size: 3)
+M(r6 uint64[uint24]) Struct(size: 3)
+M(r7 uint64[uint24]) Struct(size: 3)
+M(S+0 uint64[uint24]) Struct(size: 3)
+M(S+8 uint64[uint24]) Struct(size: 3)
=>
-M(r0 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_win.expect
index 0eb0d54..48c523a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm64_win.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 3)
-M(r1 int64) Struct(size: 3)
-M(r2 int64) Struct(size: 3)
-M(r3 int64) Struct(size: 3)
-M(r4 int64) Struct(size: 3)
-M(r5 int64) Struct(size: 3)
-M(r6 int64) Struct(size: 3)
-M(r7 int64) Struct(size: 3)
-M(S+0 int64) Struct(size: 3)
-M(S+8 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
+M(r1 uint64[uint24]) Struct(size: 3)
+M(r2 uint64[uint24]) Struct(size: 3)
+M(r3 uint64[uint24]) Struct(size: 3)
+M(r4 uint64[uint24]) Struct(size: 3)
+M(r5 uint64[uint24]) Struct(size: 3)
+M(r6 uint64[uint24]) Struct(size: 3)
+M(r7 uint64[uint24]) Struct(size: 3)
+M(S+0 uint64[uint24]) Struct(size: 3)
+M(S+8 uint64[uint24]) Struct(size: 3)
=>
-M(r0 int64) Struct(size: 3)
+M(r0 uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_android.expect
index d976ee3..159f66a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_android.expect
@@ -1,12 +1,12 @@
-M(r0 int32) Struct(size: 3)
-M(r1 int32) Struct(size: 3)
-M(r2 int32) Struct(size: 3)
-M(r3 int32) Struct(size: 3)
-M(S+0 int32) Struct(size: 3)
-M(S+4 int32) Struct(size: 3)
-M(S+8 int32) Struct(size: 3)
-M(S+12 int32) Struct(size: 3)
-M(S+16 int32) Struct(size: 3)
-M(S+20 int32) Struct(size: 3)
+M(r0 uint32[uint24]) Struct(size: 3)
+M(r1 uint32[uint24]) Struct(size: 3)
+M(r2 uint32[uint24]) Struct(size: 3)
+M(r3 uint32[uint24]) Struct(size: 3)
+M(S+0 uint32[uint24]) Struct(size: 3)
+M(S+4 uint32[uint24]) Struct(size: 3)
+M(S+8 uint32[uint24]) Struct(size: 3)
+M(S+12 uint32[uint24]) Struct(size: 3)
+M(S+16 uint32[uint24]) Struct(size: 3)
+M(S+20 uint32[uint24]) Struct(size: 3)
=>
M(r0 uint32) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_ios.expect
index d976ee3..159f66a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_ios.expect
@@ -1,12 +1,12 @@
-M(r0 int32) Struct(size: 3)
-M(r1 int32) Struct(size: 3)
-M(r2 int32) Struct(size: 3)
-M(r3 int32) Struct(size: 3)
-M(S+0 int32) Struct(size: 3)
-M(S+4 int32) Struct(size: 3)
-M(S+8 int32) Struct(size: 3)
-M(S+12 int32) Struct(size: 3)
-M(S+16 int32) Struct(size: 3)
-M(S+20 int32) Struct(size: 3)
+M(r0 uint32[uint24]) Struct(size: 3)
+M(r1 uint32[uint24]) Struct(size: 3)
+M(r2 uint32[uint24]) Struct(size: 3)
+M(r3 uint32[uint24]) Struct(size: 3)
+M(S+0 uint32[uint24]) Struct(size: 3)
+M(S+4 uint32[uint24]) Struct(size: 3)
+M(S+8 uint32[uint24]) Struct(size: 3)
+M(S+12 uint32[uint24]) Struct(size: 3)
+M(S+16 uint32[uint24]) Struct(size: 3)
+M(S+20 uint32[uint24]) Struct(size: 3)
=>
M(r0 uint32) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_linux.expect
index d976ee3..159f66a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/arm_linux.expect
@@ -1,12 +1,12 @@
-M(r0 int32) Struct(size: 3)
-M(r1 int32) Struct(size: 3)
-M(r2 int32) Struct(size: 3)
-M(r3 int32) Struct(size: 3)
-M(S+0 int32) Struct(size: 3)
-M(S+4 int32) Struct(size: 3)
-M(S+8 int32) Struct(size: 3)
-M(S+12 int32) Struct(size: 3)
-M(S+16 int32) Struct(size: 3)
-M(S+20 int32) Struct(size: 3)
+M(r0 uint32[uint24]) Struct(size: 3)
+M(r1 uint32[uint24]) Struct(size: 3)
+M(r2 uint32[uint24]) Struct(size: 3)
+M(r3 uint32[uint24]) Struct(size: 3)
+M(S+0 uint32[uint24]) Struct(size: 3)
+M(S+4 uint32[uint24]) Struct(size: 3)
+M(S+8 uint32[uint24]) Struct(size: 3)
+M(S+12 uint32[uint24]) Struct(size: 3)
+M(S+16 uint32[uint24]) Struct(size: 3)
+M(S+20 uint32[uint24]) Struct(size: 3)
=>
M(r0 uint32) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv32_linux.expect
index 9ece106..84f71a4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv32_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv32_linux.expect
@@ -1,12 +1,12 @@
-M(a0 uint32) Struct(size: 3)
-M(a1 uint32) Struct(size: 3)
-M(a2 uint32) Struct(size: 3)
-M(t3 uint32) Struct(size: 3)
-M(t4 uint32) Struct(size: 3)
-M(t5 uint32) Struct(size: 3)
-M(a6 uint32) Struct(size: 3)
-M(a7 uint32) Struct(size: 3)
-M(S+0 uint32) Struct(size: 3)
-M(S+4 uint32) Struct(size: 3)
+M(a0 uint32[uint24]) Struct(size: 3)
+M(a1 uint32[uint24]) Struct(size: 3)
+M(a2 uint32[uint24]) Struct(size: 3)
+M(t3 uint32[uint24]) Struct(size: 3)
+M(t4 uint32[uint24]) Struct(size: 3)
+M(t5 uint32[uint24]) Struct(size: 3)
+M(a6 uint32[uint24]) Struct(size: 3)
+M(a7 uint32[uint24]) Struct(size: 3)
+M(S+0 uint32[uint24]) Struct(size: 3)
+M(S+4 uint32[uint24]) Struct(size: 3)
=>
-M(a0 uint32) Struct(size: 3)
+M(a0 uint32[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv64_linux.expect
index eaa15ad..8fbe734 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/riscv64_linux.expect
@@ -1,12 +1,12 @@
-M(a0 int64) Struct(size: 3)
-M(a1 int64) Struct(size: 3)
-M(a2 int64) Struct(size: 3)
-M(t3 int64) Struct(size: 3)
-M(t4 int64) Struct(size: 3)
-M(t5 int64) Struct(size: 3)
-M(a6 int64) Struct(size: 3)
-M(a7 int64) Struct(size: 3)
-M(S+0 int64) Struct(size: 3)
-M(S+8 int64) Struct(size: 3)
+M(a0 uint64[uint24]) Struct(size: 3)
+M(a1 uint64[uint24]) Struct(size: 3)
+M(a2 uint64[uint24]) Struct(size: 3)
+M(t3 uint64[uint24]) Struct(size: 3)
+M(t4 uint64[uint24]) Struct(size: 3)
+M(t5 uint64[uint24]) Struct(size: 3)
+M(a6 uint64[uint24]) Struct(size: 3)
+M(a7 uint64[uint24]) Struct(size: 3)
+M(S+0 uint64[uint24]) Struct(size: 3)
+M(S+8 uint64[uint24]) Struct(size: 3)
=>
-M(a0 int64) Struct(size: 3)
+M(a0 uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_fuchsia.expect
index cbc1757..eb12cc3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_fuchsia.expect
@@ -1,12 +1,12 @@
-M(rdi int64) Struct(size: 3)
-M(rsi int64) Struct(size: 3)
-M(rdx int64) Struct(size: 3)
-M(rcx int64) Struct(size: 3)
-M(r8 int64) Struct(size: 3)
-M(r9 int64) Struct(size: 3)
+M(rdi uint64[uint24]) Struct(size: 3)
+M(rsi uint64[uint24]) Struct(size: 3)
+M(rdx uint64[uint24]) Struct(size: 3)
+M(rcx uint64[uint24]) Struct(size: 3)
+M(r8 uint64[uint24]) Struct(size: 3)
+M(r9 uint64[uint24]) Struct(size: 3)
S+0 Struct(size: 3)
S+8 Struct(size: 3)
S+16 Struct(size: 3)
S+24 Struct(size: 3)
=>
-M(rax int64) Struct(size: 3)
+M(rax uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_ios.expect
index cbc1757..eb12cc3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_ios.expect
@@ -1,12 +1,12 @@
-M(rdi int64) Struct(size: 3)
-M(rsi int64) Struct(size: 3)
-M(rdx int64) Struct(size: 3)
-M(rcx int64) Struct(size: 3)
-M(r8 int64) Struct(size: 3)
-M(r9 int64) Struct(size: 3)
+M(rdi uint64[uint24]) Struct(size: 3)
+M(rsi uint64[uint24]) Struct(size: 3)
+M(rdx uint64[uint24]) Struct(size: 3)
+M(rcx uint64[uint24]) Struct(size: 3)
+M(r8 uint64[uint24]) Struct(size: 3)
+M(r9 uint64[uint24]) Struct(size: 3)
S+0 Struct(size: 3)
S+8 Struct(size: 3)
S+16 Struct(size: 3)
S+24 Struct(size: 3)
=>
-M(rax int64) Struct(size: 3)
+M(rax uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_linux.expect
index cbc1757..eb12cc3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_linux.expect
@@ -1,12 +1,12 @@
-M(rdi int64) Struct(size: 3)
-M(rsi int64) Struct(size: 3)
-M(rdx int64) Struct(size: 3)
-M(rcx int64) Struct(size: 3)
-M(r8 int64) Struct(size: 3)
-M(r9 int64) Struct(size: 3)
+M(rdi uint64[uint24]) Struct(size: 3)
+M(rsi uint64[uint24]) Struct(size: 3)
+M(rdx uint64[uint24]) Struct(size: 3)
+M(rcx uint64[uint24]) Struct(size: 3)
+M(r8 uint64[uint24]) Struct(size: 3)
+M(r9 uint64[uint24]) Struct(size: 3)
S+0 Struct(size: 3)
S+8 Struct(size: 3)
S+16 Struct(size: 3)
S+24 Struct(size: 3)
=>
-M(rax int64) Struct(size: 3)
+M(rax uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_macos.expect
index cbc1757..eb12cc3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct3bytesx10/x64_macos.expect
@@ -1,12 +1,12 @@
-M(rdi int64) Struct(size: 3)
-M(rsi int64) Struct(size: 3)
-M(rdx int64) Struct(size: 3)
-M(rcx int64) Struct(size: 3)
-M(r8 int64) Struct(size: 3)
-M(r9 int64) Struct(size: 3)
+M(rdi uint64[uint24]) Struct(size: 3)
+M(rsi uint64[uint24]) Struct(size: 3)
+M(rdx uint64[uint24]) Struct(size: 3)
+M(rcx uint64[uint24]) Struct(size: 3)
+M(r8 uint64[uint24]) Struct(size: 3)
+M(r9 uint64[uint24]) Struct(size: 3)
S+0 Struct(size: 3)
S+8 Struct(size: 3)
S+16 Struct(size: 3)
S+24 Struct(size: 3)
=>
-M(rax int64) Struct(size: 3)
+M(rax uint64[uint24]) Struct(size: 3)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_android.expect
index 25a7718..c7949ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_android.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 8)
-M(r1 int64) Struct(size: 8)
-M(r2 int64) Struct(size: 8)
-M(r3 int64) Struct(size: 8)
-M(r4 int64) Struct(size: 8)
-M(r5 int64) Struct(size: 8)
-M(r6 int64) Struct(size: 8)
-M(r7 int64) Struct(size: 8)
-M(S+0 int64) Struct(size: 8)
-M(S+8 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
+M(r1 uint64) Struct(size: 8)
+M(r2 uint64) Struct(size: 8)
+M(r3 uint64) Struct(size: 8)
+M(r4 uint64) Struct(size: 8)
+M(r5 uint64) Struct(size: 8)
+M(r6 uint64) Struct(size: 8)
+M(r7 uint64) Struct(size: 8)
+M(S+0 uint64) Struct(size: 8)
+M(S+8 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_fuchsia.expect
index 25a7718..c7949ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_fuchsia.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 8)
-M(r1 int64) Struct(size: 8)
-M(r2 int64) Struct(size: 8)
-M(r3 int64) Struct(size: 8)
-M(r4 int64) Struct(size: 8)
-M(r5 int64) Struct(size: 8)
-M(r6 int64) Struct(size: 8)
-M(r7 int64) Struct(size: 8)
-M(S+0 int64) Struct(size: 8)
-M(S+8 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
+M(r1 uint64) Struct(size: 8)
+M(r2 uint64) Struct(size: 8)
+M(r3 uint64) Struct(size: 8)
+M(r4 uint64) Struct(size: 8)
+M(r5 uint64) Struct(size: 8)
+M(r6 uint64) Struct(size: 8)
+M(r7 uint64) Struct(size: 8)
+M(S+0 uint64) Struct(size: 8)
+M(S+8 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_ios.expect
index 25a7718..c7949ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_ios.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 8)
-M(r1 int64) Struct(size: 8)
-M(r2 int64) Struct(size: 8)
-M(r3 int64) Struct(size: 8)
-M(r4 int64) Struct(size: 8)
-M(r5 int64) Struct(size: 8)
-M(r6 int64) Struct(size: 8)
-M(r7 int64) Struct(size: 8)
-M(S+0 int64) Struct(size: 8)
-M(S+8 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
+M(r1 uint64) Struct(size: 8)
+M(r2 uint64) Struct(size: 8)
+M(r3 uint64) Struct(size: 8)
+M(r4 uint64) Struct(size: 8)
+M(r5 uint64) Struct(size: 8)
+M(r6 uint64) Struct(size: 8)
+M(r7 uint64) Struct(size: 8)
+M(S+0 uint64) Struct(size: 8)
+M(S+8 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_linux.expect
index 25a7718..c7949ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_linux.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 8)
-M(r1 int64) Struct(size: 8)
-M(r2 int64) Struct(size: 8)
-M(r3 int64) Struct(size: 8)
-M(r4 int64) Struct(size: 8)
-M(r5 int64) Struct(size: 8)
-M(r6 int64) Struct(size: 8)
-M(r7 int64) Struct(size: 8)
-M(S+0 int64) Struct(size: 8)
-M(S+8 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
+M(r1 uint64) Struct(size: 8)
+M(r2 uint64) Struct(size: 8)
+M(r3 uint64) Struct(size: 8)
+M(r4 uint64) Struct(size: 8)
+M(r5 uint64) Struct(size: 8)
+M(r6 uint64) Struct(size: 8)
+M(r7 uint64) Struct(size: 8)
+M(S+0 uint64) Struct(size: 8)
+M(S+8 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_macos.expect
index 25a7718..c7949ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_macos.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 8)
-M(r1 int64) Struct(size: 8)
-M(r2 int64) Struct(size: 8)
-M(r3 int64) Struct(size: 8)
-M(r4 int64) Struct(size: 8)
-M(r5 int64) Struct(size: 8)
-M(r6 int64) Struct(size: 8)
-M(r7 int64) Struct(size: 8)
-M(S+0 int64) Struct(size: 8)
-M(S+8 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
+M(r1 uint64) Struct(size: 8)
+M(r2 uint64) Struct(size: 8)
+M(r3 uint64) Struct(size: 8)
+M(r4 uint64) Struct(size: 8)
+M(r5 uint64) Struct(size: 8)
+M(r6 uint64) Struct(size: 8)
+M(r7 uint64) Struct(size: 8)
+M(S+0 uint64) Struct(size: 8)
+M(S+8 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_win.expect
index 25a7718..c7949ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm64_win.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Struct(size: 8)
-M(r1 int64) Struct(size: 8)
-M(r2 int64) Struct(size: 8)
-M(r3 int64) Struct(size: 8)
-M(r4 int64) Struct(size: 8)
-M(r5 int64) Struct(size: 8)
-M(r6 int64) Struct(size: 8)
-M(r7 int64) Struct(size: 8)
-M(S+0 int64) Struct(size: 8)
-M(S+8 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
+M(r1 uint64) Struct(size: 8)
+M(r2 uint64) Struct(size: 8)
+M(r3 uint64) Struct(size: 8)
+M(r4 uint64) Struct(size: 8)
+M(r5 uint64) Struct(size: 8)
+M(r6 uint64) Struct(size: 8)
+M(r7 uint64) Struct(size: 8)
+M(S+0 uint64) Struct(size: 8)
+M(S+8 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_android.expect
index e6b29f1..7c06f04 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_android.expect
@@ -1,12 +1,12 @@
-M(r1 int32, r2 int32) Struct(size: 8)
-M(r3 int32, S+0 int32) Struct(size: 8)
-M(S+4 int32, S+8 int32) Struct(size: 8)
-M(S+12 int32, S+16 int32) Struct(size: 8)
-M(S+20 int32, S+24 int32) Struct(size: 8)
-M(S+28 int32, S+32 int32) Struct(size: 8)
-M(S+36 int32, S+40 int32) Struct(size: 8)
-M(S+44 int32, S+48 int32) Struct(size: 8)
-M(S+52 int32, S+56 int32) Struct(size: 8)
-M(S+60 int32, S+64 int32) Struct(size: 8)
+M(r1 uint32, r2 uint32) Struct(size: 8)
+M(r3 uint32, S+0 uint32) Struct(size: 8)
+M(S+4 uint32, S+8 uint32) Struct(size: 8)
+M(S+12 uint32, S+16 uint32) Struct(size: 8)
+M(S+20 uint32, S+24 uint32) Struct(size: 8)
+M(S+28 uint32, S+32 uint32) Struct(size: 8)
+M(S+36 uint32, S+40 uint32) Struct(size: 8)
+M(S+44 uint32, S+48 uint32) Struct(size: 8)
+M(S+52 uint32, S+56 uint32) Struct(size: 8)
+M(S+60 uint32, S+64 uint32) Struct(size: 8)
=>
P(r0 uint32) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_ios.expect
index e6b29f1..7c06f04 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_ios.expect
@@ -1,12 +1,12 @@
-M(r1 int32, r2 int32) Struct(size: 8)
-M(r3 int32, S+0 int32) Struct(size: 8)
-M(S+4 int32, S+8 int32) Struct(size: 8)
-M(S+12 int32, S+16 int32) Struct(size: 8)
-M(S+20 int32, S+24 int32) Struct(size: 8)
-M(S+28 int32, S+32 int32) Struct(size: 8)
-M(S+36 int32, S+40 int32) Struct(size: 8)
-M(S+44 int32, S+48 int32) Struct(size: 8)
-M(S+52 int32, S+56 int32) Struct(size: 8)
-M(S+60 int32, S+64 int32) Struct(size: 8)
+M(r1 uint32, r2 uint32) Struct(size: 8)
+M(r3 uint32, S+0 uint32) Struct(size: 8)
+M(S+4 uint32, S+8 uint32) Struct(size: 8)
+M(S+12 uint32, S+16 uint32) Struct(size: 8)
+M(S+20 uint32, S+24 uint32) Struct(size: 8)
+M(S+28 uint32, S+32 uint32) Struct(size: 8)
+M(S+36 uint32, S+40 uint32) Struct(size: 8)
+M(S+44 uint32, S+48 uint32) Struct(size: 8)
+M(S+52 uint32, S+56 uint32) Struct(size: 8)
+M(S+60 uint32, S+64 uint32) Struct(size: 8)
=>
P(r0 uint32) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_linux.expect
index e6b29f1..7c06f04 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/arm_linux.expect
@@ -1,12 +1,12 @@
-M(r1 int32, r2 int32) Struct(size: 8)
-M(r3 int32, S+0 int32) Struct(size: 8)
-M(S+4 int32, S+8 int32) Struct(size: 8)
-M(S+12 int32, S+16 int32) Struct(size: 8)
-M(S+20 int32, S+24 int32) Struct(size: 8)
-M(S+28 int32, S+32 int32) Struct(size: 8)
-M(S+36 int32, S+40 int32) Struct(size: 8)
-M(S+44 int32, S+48 int32) Struct(size: 8)
-M(S+52 int32, S+56 int32) Struct(size: 8)
-M(S+60 int32, S+64 int32) Struct(size: 8)
+M(r1 uint32, r2 uint32) Struct(size: 8)
+M(r3 uint32, S+0 uint32) Struct(size: 8)
+M(S+4 uint32, S+8 uint32) Struct(size: 8)
+M(S+12 uint32, S+16 uint32) Struct(size: 8)
+M(S+20 uint32, S+24 uint32) Struct(size: 8)
+M(S+28 uint32, S+32 uint32) Struct(size: 8)
+M(S+36 uint32, S+40 uint32) Struct(size: 8)
+M(S+44 uint32, S+48 uint32) Struct(size: 8)
+M(S+52 uint32, S+56 uint32) Struct(size: 8)
+M(S+60 uint32, S+64 uint32) Struct(size: 8)
=>
P(r0 uint32) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/riscv64_linux.expect
index 5de4c6a..2244266 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesPackedx10/riscv64_linux.expect
@@ -1,12 +1,12 @@
-M(a0 int64) Struct(size: 8)
-M(a1 int64) Struct(size: 8)
-M(a2 int64) Struct(size: 8)
-M(t3 int64) Struct(size: 8)
-M(t4 int64) Struct(size: 8)
-M(t5 int64) Struct(size: 8)
-M(a6 int64) Struct(size: 8)
-M(a7 int64) Struct(size: 8)
-M(S+0 int64) Struct(size: 8)
-M(S+8 int64) Struct(size: 8)
+M(a0 uint64) Struct(size: 8)
+M(a1 uint64) Struct(size: 8)
+M(a2 uint64) Struct(size: 8)
+M(t3 uint64) Struct(size: 8)
+M(t4 uint64) Struct(size: 8)
+M(t5 uint64) Struct(size: 8)
+M(a6 uint64) Struct(size: 8)
+M(a7 uint64) Struct(size: 8)
+M(S+0 uint64) Struct(size: 8)
+M(S+8 uint64) Struct(size: 8)
=>
-M(a0 int64) Struct(size: 8)
+M(a0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_android.expect
index a6404ed..02838dc 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_android.expect
@@ -1,3 +1,3 @@
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_fuchsia.expect
index a6404ed..02838dc 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_fuchsia.expect
@@ -1,3 +1,3 @@
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_ios.expect
index a6404ed..02838dc 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_ios.expect
@@ -1,3 +1,3 @@
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_linux.expect
index a6404ed..02838dc 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_linux.expect
@@ -1,3 +1,3 @@
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_macos.expect
index a6404ed..02838dc 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_macos.expect
@@ -1,3 +1,3 @@
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_win.expect
index a6404ed..02838dc 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm64_win.expect
@@ -1,3 +1,3 @@
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
=>
-M(r0 int64) Struct(size: 8)
+M(r0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_android.expect
index 39b6e97..3b4e4a2 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_android.expect
@@ -1,3 +1,3 @@
-M(r1 int32, r2 int32) Struct(size: 8)
+M(r1 uint32, r2 uint32) Struct(size: 8)
=>
P(r0 uint32) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_ios.expect
index 39b6e97..3b4e4a2 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_ios.expect
@@ -1,3 +1,3 @@
-M(r1 int32, r2 int32) Struct(size: 8)
+M(r1 uint32, r2 uint32) Struct(size: 8)
=>
P(r0 uint32) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_linux.expect
index 39b6e97..3b4e4a2 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/arm_linux.expect
@@ -1,3 +1,3 @@
-M(r1 int32, r2 int32) Struct(size: 8)
+M(r1 uint32, r2 uint32) Struct(size: 8)
=>
P(r0 uint32) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/riscv64_linux.expect
index f1b1ff8..7a5a3ec 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/riscv64_linux.expect
@@ -1,3 +1,3 @@
-M(a0 int64) Struct(size: 8)
+M(a0 uint64) Struct(size: 8)
=>
-M(a0 int64) Struct(size: 8)
+M(a0 uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_fuchsia.expect
index fa9bb3c..787dcdb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_fuchsia.expect
@@ -1,3 +1,3 @@
-M(rdi int64) Struct(size: 8)
+M(rdi uint64) Struct(size: 8)
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_ios.expect
index fa9bb3c..787dcdb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_ios.expect
@@ -1,3 +1,3 @@
-M(rdi int64) Struct(size: 8)
+M(rdi uint64) Struct(size: 8)
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_linux.expect
index fa9bb3c..787dcdb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_linux.expect
@@ -1,3 +1,3 @@
-M(rdi int64) Struct(size: 8)
+M(rdi uint64) Struct(size: 8)
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_macos.expect
index fa9bb3c..787dcdb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/struct8bytesx1/x64_macos.expect
@@ -1,3 +1,3 @@
-M(rdi int64) Struct(size: 8)
+M(rdi uint64) Struct(size: 8)
=>
-M(rax int64) Struct(size: 8)
+M(rax uint64) Struct(size: 8)
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_android.expect
index ef383b1..c37c611 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_android.expect
@@ -1,13 +1,13 @@
-M(r0 int64, r1 int64) Struct(size: 9)
-M(r2 int64, r3 int64) Struct(size: 9)
-M(r4 int64, r5 int64) Struct(size: 9)
-M(r6 int64, r7 int64) Struct(size: 9)
-M(S+0 int64, S+8 int64) Struct(size: 9)
-M(S+16 int64, S+24 int64) Struct(size: 9)
-M(S+32 int64, S+40 int64) Struct(size: 9)
-M(S+48 int64, S+56 int64) Struct(size: 9)
-M(S+64 int64, S+72 int64) Struct(size: 9)
-M(S+80 int64, S+88 int64) Struct(size: 9)
+M(r0 uint64, r1 uint64[uint8]) Struct(size: 9)
+M(r2 uint64, r3 uint64[uint8]) Struct(size: 9)
+M(r4 uint64, r5 uint64[uint8]) Struct(size: 9)
+M(r6 uint64, r7 uint64[uint8]) Struct(size: 9)
+M(S+0 uint64, S+8 uint64[uint8]) Struct(size: 9)
+M(S+16 uint64, S+24 uint64[uint8]) Struct(size: 9)
+M(S+32 uint64, S+40 uint64[uint8]) Struct(size: 9)
+M(S+48 uint64, S+56 uint64[uint8]) Struct(size: 9)
+M(S+64 uint64, S+72 uint64[uint8]) Struct(size: 9)
+M(S+80 uint64, S+88 uint64[uint8]) Struct(size: 9)
v0 double
S+96 int32
S+104 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_fuchsia.expect
index ef383b1..c37c611 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_fuchsia.expect
@@ -1,13 +1,13 @@
-M(r0 int64, r1 int64) Struct(size: 9)
-M(r2 int64, r3 int64) Struct(size: 9)
-M(r4 int64, r5 int64) Struct(size: 9)
-M(r6 int64, r7 int64) Struct(size: 9)
-M(S+0 int64, S+8 int64) Struct(size: 9)
-M(S+16 int64, S+24 int64) Struct(size: 9)
-M(S+32 int64, S+40 int64) Struct(size: 9)
-M(S+48 int64, S+56 int64) Struct(size: 9)
-M(S+64 int64, S+72 int64) Struct(size: 9)
-M(S+80 int64, S+88 int64) Struct(size: 9)
+M(r0 uint64, r1 uint64[uint8]) Struct(size: 9)
+M(r2 uint64, r3 uint64[uint8]) Struct(size: 9)
+M(r4 uint64, r5 uint64[uint8]) Struct(size: 9)
+M(r6 uint64, r7 uint64[uint8]) Struct(size: 9)
+M(S+0 uint64, S+8 uint64[uint8]) Struct(size: 9)
+M(S+16 uint64, S+24 uint64[uint8]) Struct(size: 9)
+M(S+32 uint64, S+40 uint64[uint8]) Struct(size: 9)
+M(S+48 uint64, S+56 uint64[uint8]) Struct(size: 9)
+M(S+64 uint64, S+72 uint64[uint8]) Struct(size: 9)
+M(S+80 uint64, S+88 uint64[uint8]) Struct(size: 9)
v0 double
S+96 int32
S+104 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_ios.expect
index 8cdaf17..c53baa0 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_ios.expect
@@ -1,13 +1,13 @@
-M(r0 int64, r1 int64) Struct(size: 9)
-M(r2 int64, r3 int64) Struct(size: 9)
-M(r4 int64, r5 int64) Struct(size: 9)
-M(r6 int64, r7 int64) Struct(size: 9)
-M(S+0 int64, S+8 int64) Struct(size: 9)
-M(S+16 int64, S+24 int64) Struct(size: 9)
-M(S+32 int64, S+40 int64) Struct(size: 9)
-M(S+48 int64, S+56 int64) Struct(size: 9)
-M(S+64 int64, S+72 int64) Struct(size: 9)
-M(S+80 int64, S+88 int64) Struct(size: 9)
+M(r0 uint64, r1 uint64[uint8]) Struct(size: 9)
+M(r2 uint64, r3 uint64[uint8]) Struct(size: 9)
+M(r4 uint64, r5 uint64[uint8]) Struct(size: 9)
+M(r6 uint64, r7 uint64[uint8]) Struct(size: 9)
+M(S+0 uint64, S+8 uint64[uint8]) Struct(size: 9)
+M(S+16 uint64, S+24 uint64[uint8]) Struct(size: 9)
+M(S+32 uint64, S+40 uint64[uint8]) Struct(size: 9)
+M(S+48 uint64, S+56 uint64[uint8]) Struct(size: 9)
+M(S+64 uint64, S+72 uint64[uint8]) Struct(size: 9)
+M(S+80 uint64, S+88 uint64[uint8]) Struct(size: 9)
v0 double
S+96 int32
S+100 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_linux.expect
index ef383b1..c37c611 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_linux.expect
@@ -1,13 +1,13 @@
-M(r0 int64, r1 int64) Struct(size: 9)
-M(r2 int64, r3 int64) Struct(size: 9)
-M(r4 int64, r5 int64) Struct(size: 9)
-M(r6 int64, r7 int64) Struct(size: 9)
-M(S+0 int64, S+8 int64) Struct(size: 9)
-M(S+16 int64, S+24 int64) Struct(size: 9)
-M(S+32 int64, S+40 int64) Struct(size: 9)
-M(S+48 int64, S+56 int64) Struct(size: 9)
-M(S+64 int64, S+72 int64) Struct(size: 9)
-M(S+80 int64, S+88 int64) Struct(size: 9)
+M(r0 uint64, r1 uint64[uint8]) Struct(size: 9)
+M(r2 uint64, r3 uint64[uint8]) Struct(size: 9)
+M(r4 uint64, r5 uint64[uint8]) Struct(size: 9)
+M(r6 uint64, r7 uint64[uint8]) Struct(size: 9)
+M(S+0 uint64, S+8 uint64[uint8]) Struct(size: 9)
+M(S+16 uint64, S+24 uint64[uint8]) Struct(size: 9)
+M(S+32 uint64, S+40 uint64[uint8]) Struct(size: 9)
+M(S+48 uint64, S+56 uint64[uint8]) Struct(size: 9)
+M(S+64 uint64, S+72 uint64[uint8]) Struct(size: 9)
+M(S+80 uint64, S+88 uint64[uint8]) Struct(size: 9)
v0 double
S+96 int32
S+104 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_macos.expect
index 8cdaf17..c53baa0 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_macos.expect
@@ -1,13 +1,13 @@
-M(r0 int64, r1 int64) Struct(size: 9)
-M(r2 int64, r3 int64) Struct(size: 9)
-M(r4 int64, r5 int64) Struct(size: 9)
-M(r6 int64, r7 int64) Struct(size: 9)
-M(S+0 int64, S+8 int64) Struct(size: 9)
-M(S+16 int64, S+24 int64) Struct(size: 9)
-M(S+32 int64, S+40 int64) Struct(size: 9)
-M(S+48 int64, S+56 int64) Struct(size: 9)
-M(S+64 int64, S+72 int64) Struct(size: 9)
-M(S+80 int64, S+88 int64) Struct(size: 9)
+M(r0 uint64, r1 uint64[uint8]) Struct(size: 9)
+M(r2 uint64, r3 uint64[uint8]) Struct(size: 9)
+M(r4 uint64, r5 uint64[uint8]) Struct(size: 9)
+M(r6 uint64, r7 uint64[uint8]) Struct(size: 9)
+M(S+0 uint64, S+8 uint64[uint8]) Struct(size: 9)
+M(S+16 uint64, S+24 uint64[uint8]) Struct(size: 9)
+M(S+32 uint64, S+40 uint64[uint8]) Struct(size: 9)
+M(S+48 uint64, S+56 uint64[uint8]) Struct(size: 9)
+M(S+64 uint64, S+72 uint64[uint8]) Struct(size: 9)
+M(S+80 uint64, S+88 uint64[uint8]) Struct(size: 9)
v0 double
S+96 int32
S+100 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_win.expect
index ef383b1..c37c611 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm64_win.expect
@@ -1,13 +1,13 @@
-M(r0 int64, r1 int64) Struct(size: 9)
-M(r2 int64, r3 int64) Struct(size: 9)
-M(r4 int64, r5 int64) Struct(size: 9)
-M(r6 int64, r7 int64) Struct(size: 9)
-M(S+0 int64, S+8 int64) Struct(size: 9)
-M(S+16 int64, S+24 int64) Struct(size: 9)
-M(S+32 int64, S+40 int64) Struct(size: 9)
-M(S+48 int64, S+56 int64) Struct(size: 9)
-M(S+64 int64, S+72 int64) Struct(size: 9)
-M(S+80 int64, S+88 int64) Struct(size: 9)
+M(r0 uint64, r1 uint64[uint8]) Struct(size: 9)
+M(r2 uint64, r3 uint64[uint8]) Struct(size: 9)
+M(r4 uint64, r5 uint64[uint8]) Struct(size: 9)
+M(r6 uint64, r7 uint64[uint8]) Struct(size: 9)
+M(S+0 uint64, S+8 uint64[uint8]) Struct(size: 9)
+M(S+16 uint64, S+24 uint64[uint8]) Struct(size: 9)
+M(S+32 uint64, S+40 uint64[uint8]) Struct(size: 9)
+M(S+48 uint64, S+56 uint64[uint8]) Struct(size: 9)
+M(S+64 uint64, S+72 uint64[uint8]) Struct(size: 9)
+M(S+80 uint64, S+88 uint64[uint8]) Struct(size: 9)
v0 double
S+96 int32
S+104 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_android.expect
index ec8c36b..e7ebde4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_android.expect
@@ -1,13 +1,13 @@
-M(r0 int32, r1 int32, r2 int32) Struct(size: 9)
-M(r3 int32, S+0 int32, S+4 int32) Struct(size: 9)
-M(S+8 int32, S+12 int32, S+16 int32) Struct(size: 9)
-M(S+20 int32, S+24 int32, S+28 int32) Struct(size: 9)
-M(S+32 int32, S+36 int32, S+40 int32) Struct(size: 9)
-M(S+44 int32, S+48 int32, S+52 int32) Struct(size: 9)
-M(S+56 int32, S+60 int32, S+64 int32) Struct(size: 9)
-M(S+68 int32, S+72 int32, S+76 int32) Struct(size: 9)
-M(S+80 int32, S+84 int32, S+88 int32) Struct(size: 9)
-M(S+92 int32, S+96 int32, S+100 int32) Struct(size: 9)
+M(r0 uint32, r1 uint32, r2 uint32[uint8]) Struct(size: 9)
+M(r3 uint32, S+0 uint32, S+4 uint32[uint8]) Struct(size: 9)
+M(S+8 uint32, S+12 uint32, S+16 uint32[uint8]) Struct(size: 9)
+M(S+20 uint32, S+24 uint32, S+28 uint32[uint8]) Struct(size: 9)
+M(S+32 uint32, S+36 uint32, S+40 uint32[uint8]) Struct(size: 9)
+M(S+44 uint32, S+48 uint32, S+52 uint32[uint8]) Struct(size: 9)
+M(S+56 uint32, S+60 uint32, S+64 uint32[uint8]) Struct(size: 9)
+M(S+68 uint32, S+72 uint32, S+76 uint32[uint8]) Struct(size: 9)
+M(S+80 uint32, S+84 uint32, S+88 uint32[uint8]) Struct(size: 9)
+M(S+92 uint32, S+96 uint32, S+100 uint32[uint8]) Struct(size: 9)
S+104 double
S+112 int32
S+116 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_ios.expect
index 78ee91b..d710dc3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_ios.expect
@@ -1,13 +1,13 @@
-M(r0 int32, r1 int32, r2 int32) Struct(size: 9)
-M(r3 int32, S+0 int32, S+4 int32) Struct(size: 9)
-M(S+8 int32, S+12 int32, S+16 int32) Struct(size: 9)
-M(S+20 int32, S+24 int32, S+28 int32) Struct(size: 9)
-M(S+32 int32, S+36 int32, S+40 int32) Struct(size: 9)
-M(S+44 int32, S+48 int32, S+52 int32) Struct(size: 9)
-M(S+56 int32, S+60 int32, S+64 int32) Struct(size: 9)
-M(S+68 int32, S+72 int32, S+76 int32) Struct(size: 9)
-M(S+80 int32, S+84 int32, S+88 int32) Struct(size: 9)
-M(S+92 int32, S+96 int32, S+100 int32) Struct(size: 9)
+M(r0 uint32, r1 uint32, r2 uint32[uint8]) Struct(size: 9)
+M(r3 uint32, S+0 uint32, S+4 uint32[uint8]) Struct(size: 9)
+M(S+8 uint32, S+12 uint32, S+16 uint32[uint8]) Struct(size: 9)
+M(S+20 uint32, S+24 uint32, S+28 uint32[uint8]) Struct(size: 9)
+M(S+32 uint32, S+36 uint32, S+40 uint32[uint8]) Struct(size: 9)
+M(S+44 uint32, S+48 uint32, S+52 uint32[uint8]) Struct(size: 9)
+M(S+56 uint32, S+60 uint32, S+64 uint32[uint8]) Struct(size: 9)
+M(S+68 uint32, S+72 uint32, S+76 uint32[uint8]) Struct(size: 9)
+M(S+80 uint32, S+84 uint32, S+88 uint32[uint8]) Struct(size: 9)
+M(S+92 uint32, S+96 uint32, S+100 uint32[uint8]) Struct(size: 9)
d0 double
S+104 int32
S+108 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_linux.expect
index 78ee91b..d710dc3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/arm_linux.expect
@@ -1,13 +1,13 @@
-M(r0 int32, r1 int32, r2 int32) Struct(size: 9)
-M(r3 int32, S+0 int32, S+4 int32) Struct(size: 9)
-M(S+8 int32, S+12 int32, S+16 int32) Struct(size: 9)
-M(S+20 int32, S+24 int32, S+28 int32) Struct(size: 9)
-M(S+32 int32, S+36 int32, S+40 int32) Struct(size: 9)
-M(S+44 int32, S+48 int32, S+52 int32) Struct(size: 9)
-M(S+56 int32, S+60 int32, S+64 int32) Struct(size: 9)
-M(S+68 int32, S+72 int32, S+76 int32) Struct(size: 9)
-M(S+80 int32, S+84 int32, S+88 int32) Struct(size: 9)
-M(S+92 int32, S+96 int32, S+100 int32) Struct(size: 9)
+M(r0 uint32, r1 uint32, r2 uint32[uint8]) Struct(size: 9)
+M(r3 uint32, S+0 uint32, S+4 uint32[uint8]) Struct(size: 9)
+M(S+8 uint32, S+12 uint32, S+16 uint32[uint8]) Struct(size: 9)
+M(S+20 uint32, S+24 uint32, S+28 uint32[uint8]) Struct(size: 9)
+M(S+32 uint32, S+36 uint32, S+40 uint32[uint8]) Struct(size: 9)
+M(S+44 uint32, S+48 uint32, S+52 uint32[uint8]) Struct(size: 9)
+M(S+56 uint32, S+60 uint32, S+64 uint32[uint8]) Struct(size: 9)
+M(S+68 uint32, S+72 uint32, S+76 uint32[uint8]) Struct(size: 9)
+M(S+80 uint32, S+84 uint32, S+88 uint32[uint8]) Struct(size: 9)
+M(S+92 uint32, S+96 uint32, S+100 uint32[uint8]) Struct(size: 9)
d0 double
S+104 int32
S+108 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/structPacked/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/structPacked/riscv64_linux.expect
index 0f037e9..0192599 100644
--- a/runtime/vm/compiler/ffi/unit_tests/structPacked/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/structPacked/riscv64_linux.expect
@@ -6,8 +6,8 @@
M(t5 int32[int8], fa5 double) Struct(size: 9)
M(a6 int32[int8], fa6 double) Struct(size: 9)
M(a7 int32[int8], fa7 double) Struct(size: 9)
-M(S+0 int64, S+8 int64) Struct(size: 9)
-M(S+16 int64, S+24 int64) Struct(size: 9)
+M(S+0 uint64, S+8 uint64[uint8]) Struct(size: 9)
+M(S+16 uint64, S+24 uint64[uint8]) Struct(size: 9)
S+32 double
S+40 int32
S+48 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/arm_android.expect
index 4b1f92d..a50eb0a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/arm_android.expect
@@ -1,13 +1,13 @@
-M(r1 int32, r2 int32, r3 int32, S+0 int32) Union(size: 16)
-M(S+4 int32, S+8 int32, S+12 int32, S+16 int32) Union(size: 16)
-M(S+20 int32, S+24 int32, S+28 int32, S+32 int32) Union(size: 16)
-M(S+36 int32, S+40 int32, S+44 int32, S+48 int32) Union(size: 16)
-M(S+52 int32, S+56 int32, S+60 int32, S+64 int32) Union(size: 16)
-M(S+68 int32, S+72 int32, S+76 int32, S+80 int32) Union(size: 16)
-M(S+84 int32, S+88 int32, S+92 int32, S+96 int32) Union(size: 16)
-M(S+100 int32, S+104 int32, S+108 int32, S+112 int32) Union(size: 16)
-M(S+116 int32, S+120 int32, S+124 int32, S+128 int32) Union(size: 16)
+M(r1 uint32, r2 uint32, r3 uint32, S+0 uint32) Union(size: 16)
+M(S+4 uint32, S+8 uint32, S+12 uint32, S+16 uint32) Union(size: 16)
+M(S+20 uint32, S+24 uint32, S+28 uint32, S+32 uint32) Union(size: 16)
+M(S+36 uint32, S+40 uint32, S+44 uint32, S+48 uint32) Union(size: 16)
+M(S+52 uint32, S+56 uint32, S+60 uint32, S+64 uint32) Union(size: 16)
+M(S+68 uint32, S+72 uint32, S+76 uint32, S+80 uint32) Union(size: 16)
+M(S+84 uint32, S+88 uint32, S+92 uint32, S+96 uint32) Union(size: 16)
+M(S+100 uint32, S+104 uint32, S+108 uint32, S+112 uint32) Union(size: 16)
+M(S+116 uint32, S+120 uint32, S+124 uint32, S+128 uint32) Union(size: 16)
S+132 int32[int8]
-M(S+136 int32, S+140 int32, S+144 int32, S+148 int32) Union(size: 16)
+M(S+136 uint32, S+140 uint32, S+144 uint32, S+148 uint32) Union(size: 16)
=>
P(r0 uint32) Union(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/riscv64_linux.expect
index 865967e..34990c8 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union16bytesHomogenousx10/riscv64_linux.expect
@@ -1,13 +1,13 @@
-M(a0 int64, a1 int64) Union(size: 16)
-M(a2 int64, t3 int64) Union(size: 16)
-M(t4 int64, t5 int64) Union(size: 16)
-M(a6 int64, a7 int64) Union(size: 16)
-M(S+0 int64, S+8 int64) Union(size: 16)
-M(S+16 int64, S+24 int64) Union(size: 16)
-M(S+32 int64, S+40 int64) Union(size: 16)
-M(S+48 int64, S+56 int64) Union(size: 16)
-M(S+64 int64, S+72 int64) Union(size: 16)
+M(a0 uint64, a1 uint64) Union(size: 16)
+M(a2 uint64, t3 uint64) Union(size: 16)
+M(t4 uint64, t5 uint64) Union(size: 16)
+M(a6 uint64, a7 uint64) Union(size: 16)
+M(S+0 uint64, S+8 uint64) Union(size: 16)
+M(S+16 uint64, S+24 uint64) Union(size: 16)
+M(S+32 uint64, S+40 uint64) Union(size: 16)
+M(S+48 uint64, S+56 uint64) Union(size: 16)
+M(S+64 uint64, S+72 uint64) Union(size: 16)
S+80 int8
-M(S+88 int64, S+96 int64) Union(size: 16)
+M(S+88 uint64, S+96 uint64) Union(size: 16)
=>
-M(a0 int64, a1 int64) Union(size: 16)
+M(a0 uint64, a1 uint64) Union(size: 16)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_android.expect
index 5e76e36..21f979a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_android.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Union(size: 5)
-M(r1 int64) Union(size: 5)
-M(r2 int64) Union(size: 5)
-M(r3 int64) Union(size: 5)
-M(r4 int64) Union(size: 5)
-M(r5 int64) Union(size: 5)
-M(r6 int64) Union(size: 5)
-M(r7 int64) Union(size: 5)
-M(S+0 int64) Union(size: 5)
-M(S+8 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
+M(r1 uint64[uint40]) Union(size: 5)
+M(r2 uint64[uint40]) Union(size: 5)
+M(r3 uint64[uint40]) Union(size: 5)
+M(r4 uint64[uint40]) Union(size: 5)
+M(r5 uint64[uint40]) Union(size: 5)
+M(r6 uint64[uint40]) Union(size: 5)
+M(r7 uint64[uint40]) Union(size: 5)
+M(S+0 uint64[uint40]) Union(size: 5)
+M(S+8 uint64[uint40]) Union(size: 5)
=>
-M(r0 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_fuchsia.expect
index 5e76e36..21f979a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_fuchsia.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Union(size: 5)
-M(r1 int64) Union(size: 5)
-M(r2 int64) Union(size: 5)
-M(r3 int64) Union(size: 5)
-M(r4 int64) Union(size: 5)
-M(r5 int64) Union(size: 5)
-M(r6 int64) Union(size: 5)
-M(r7 int64) Union(size: 5)
-M(S+0 int64) Union(size: 5)
-M(S+8 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
+M(r1 uint64[uint40]) Union(size: 5)
+M(r2 uint64[uint40]) Union(size: 5)
+M(r3 uint64[uint40]) Union(size: 5)
+M(r4 uint64[uint40]) Union(size: 5)
+M(r5 uint64[uint40]) Union(size: 5)
+M(r6 uint64[uint40]) Union(size: 5)
+M(r7 uint64[uint40]) Union(size: 5)
+M(S+0 uint64[uint40]) Union(size: 5)
+M(S+8 uint64[uint40]) Union(size: 5)
=>
-M(r0 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_ios.expect
index 5e76e36..21f979a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_ios.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Union(size: 5)
-M(r1 int64) Union(size: 5)
-M(r2 int64) Union(size: 5)
-M(r3 int64) Union(size: 5)
-M(r4 int64) Union(size: 5)
-M(r5 int64) Union(size: 5)
-M(r6 int64) Union(size: 5)
-M(r7 int64) Union(size: 5)
-M(S+0 int64) Union(size: 5)
-M(S+8 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
+M(r1 uint64[uint40]) Union(size: 5)
+M(r2 uint64[uint40]) Union(size: 5)
+M(r3 uint64[uint40]) Union(size: 5)
+M(r4 uint64[uint40]) Union(size: 5)
+M(r5 uint64[uint40]) Union(size: 5)
+M(r6 uint64[uint40]) Union(size: 5)
+M(r7 uint64[uint40]) Union(size: 5)
+M(S+0 uint64[uint40]) Union(size: 5)
+M(S+8 uint64[uint40]) Union(size: 5)
=>
-M(r0 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_linux.expect
index 5e76e36..21f979a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_linux.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Union(size: 5)
-M(r1 int64) Union(size: 5)
-M(r2 int64) Union(size: 5)
-M(r3 int64) Union(size: 5)
-M(r4 int64) Union(size: 5)
-M(r5 int64) Union(size: 5)
-M(r6 int64) Union(size: 5)
-M(r7 int64) Union(size: 5)
-M(S+0 int64) Union(size: 5)
-M(S+8 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
+M(r1 uint64[uint40]) Union(size: 5)
+M(r2 uint64[uint40]) Union(size: 5)
+M(r3 uint64[uint40]) Union(size: 5)
+M(r4 uint64[uint40]) Union(size: 5)
+M(r5 uint64[uint40]) Union(size: 5)
+M(r6 uint64[uint40]) Union(size: 5)
+M(r7 uint64[uint40]) Union(size: 5)
+M(S+0 uint64[uint40]) Union(size: 5)
+M(S+8 uint64[uint40]) Union(size: 5)
=>
-M(r0 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_macos.expect
index 5e76e36..21f979a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_macos.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Union(size: 5)
-M(r1 int64) Union(size: 5)
-M(r2 int64) Union(size: 5)
-M(r3 int64) Union(size: 5)
-M(r4 int64) Union(size: 5)
-M(r5 int64) Union(size: 5)
-M(r6 int64) Union(size: 5)
-M(r7 int64) Union(size: 5)
-M(S+0 int64) Union(size: 5)
-M(S+8 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
+M(r1 uint64[uint40]) Union(size: 5)
+M(r2 uint64[uint40]) Union(size: 5)
+M(r3 uint64[uint40]) Union(size: 5)
+M(r4 uint64[uint40]) Union(size: 5)
+M(r5 uint64[uint40]) Union(size: 5)
+M(r6 uint64[uint40]) Union(size: 5)
+M(r7 uint64[uint40]) Union(size: 5)
+M(S+0 uint64[uint40]) Union(size: 5)
+M(S+8 uint64[uint40]) Union(size: 5)
=>
-M(r0 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_win.expect
index 5e76e36..21f979a 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm64_win.expect
@@ -1,12 +1,12 @@
-M(r0 int64) Union(size: 5)
-M(r1 int64) Union(size: 5)
-M(r2 int64) Union(size: 5)
-M(r3 int64) Union(size: 5)
-M(r4 int64) Union(size: 5)
-M(r5 int64) Union(size: 5)
-M(r6 int64) Union(size: 5)
-M(r7 int64) Union(size: 5)
-M(S+0 int64) Union(size: 5)
-M(S+8 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
+M(r1 uint64[uint40]) Union(size: 5)
+M(r2 uint64[uint40]) Union(size: 5)
+M(r3 uint64[uint40]) Union(size: 5)
+M(r4 uint64[uint40]) Union(size: 5)
+M(r5 uint64[uint40]) Union(size: 5)
+M(r6 uint64[uint40]) Union(size: 5)
+M(r7 uint64[uint40]) Union(size: 5)
+M(S+0 uint64[uint40]) Union(size: 5)
+M(S+8 uint64[uint40]) Union(size: 5)
=>
-M(r0 int64) Union(size: 5)
+M(r0 uint64[uint40]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_android.expect
index 395d3f5..8381789 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_android.expect
@@ -1,12 +1,12 @@
-M(r1 int32, r2 int32) Union(size: 5)
-M(r3 int32, S+0 int32) Union(size: 5)
-M(S+4 int32, S+8 int32) Union(size: 5)
-M(S+12 int32, S+16 int32) Union(size: 5)
-M(S+20 int32, S+24 int32) Union(size: 5)
-M(S+28 int32, S+32 int32) Union(size: 5)
-M(S+36 int32, S+40 int32) Union(size: 5)
-M(S+44 int32, S+48 int32) Union(size: 5)
-M(S+52 int32, S+56 int32) Union(size: 5)
-M(S+60 int32, S+64 int32) Union(size: 5)
+M(r1 uint32, r2 uint32[uint8]) Union(size: 5)
+M(r3 uint32, S+0 uint32[uint8]) Union(size: 5)
+M(S+4 uint32, S+8 uint32[uint8]) Union(size: 5)
+M(S+12 uint32, S+16 uint32[uint8]) Union(size: 5)
+M(S+20 uint32, S+24 uint32[uint8]) Union(size: 5)
+M(S+28 uint32, S+32 uint32[uint8]) Union(size: 5)
+M(S+36 uint32, S+40 uint32[uint8]) Union(size: 5)
+M(S+44 uint32, S+48 uint32[uint8]) Union(size: 5)
+M(S+52 uint32, S+56 uint32[uint8]) Union(size: 5)
+M(S+60 uint32, S+64 uint32[uint8]) Union(size: 5)
=>
P(r0 uint32) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_ios.expect
index 395d3f5..8381789 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_ios.expect
@@ -1,12 +1,12 @@
-M(r1 int32, r2 int32) Union(size: 5)
-M(r3 int32, S+0 int32) Union(size: 5)
-M(S+4 int32, S+8 int32) Union(size: 5)
-M(S+12 int32, S+16 int32) Union(size: 5)
-M(S+20 int32, S+24 int32) Union(size: 5)
-M(S+28 int32, S+32 int32) Union(size: 5)
-M(S+36 int32, S+40 int32) Union(size: 5)
-M(S+44 int32, S+48 int32) Union(size: 5)
-M(S+52 int32, S+56 int32) Union(size: 5)
-M(S+60 int32, S+64 int32) Union(size: 5)
+M(r1 uint32, r2 uint32[uint8]) Union(size: 5)
+M(r3 uint32, S+0 uint32[uint8]) Union(size: 5)
+M(S+4 uint32, S+8 uint32[uint8]) Union(size: 5)
+M(S+12 uint32, S+16 uint32[uint8]) Union(size: 5)
+M(S+20 uint32, S+24 uint32[uint8]) Union(size: 5)
+M(S+28 uint32, S+32 uint32[uint8]) Union(size: 5)
+M(S+36 uint32, S+40 uint32[uint8]) Union(size: 5)
+M(S+44 uint32, S+48 uint32[uint8]) Union(size: 5)
+M(S+52 uint32, S+56 uint32[uint8]) Union(size: 5)
+M(S+60 uint32, S+64 uint32[uint8]) Union(size: 5)
=>
P(r0 uint32) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_linux.expect
index 395d3f5..8381789 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/arm_linux.expect
@@ -1,12 +1,12 @@
-M(r1 int32, r2 int32) Union(size: 5)
-M(r3 int32, S+0 int32) Union(size: 5)
-M(S+4 int32, S+8 int32) Union(size: 5)
-M(S+12 int32, S+16 int32) Union(size: 5)
-M(S+20 int32, S+24 int32) Union(size: 5)
-M(S+28 int32, S+32 int32) Union(size: 5)
-M(S+36 int32, S+40 int32) Union(size: 5)
-M(S+44 int32, S+48 int32) Union(size: 5)
-M(S+52 int32, S+56 int32) Union(size: 5)
-M(S+60 int32, S+64 int32) Union(size: 5)
+M(r1 uint32, r2 uint32[uint8]) Union(size: 5)
+M(r3 uint32, S+0 uint32[uint8]) Union(size: 5)
+M(S+4 uint32, S+8 uint32[uint8]) Union(size: 5)
+M(S+12 uint32, S+16 uint32[uint8]) Union(size: 5)
+M(S+20 uint32, S+24 uint32[uint8]) Union(size: 5)
+M(S+28 uint32, S+32 uint32[uint8]) Union(size: 5)
+M(S+36 uint32, S+40 uint32[uint8]) Union(size: 5)
+M(S+44 uint32, S+48 uint32[uint8]) Union(size: 5)
+M(S+52 uint32, S+56 uint32[uint8]) Union(size: 5)
+M(S+60 uint32, S+64 uint32[uint8]) Union(size: 5)
=>
P(r0 uint32) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv32_linux.expect
index 2292738..1519a3e 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv32_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv32_linux.expect
@@ -1,12 +1,12 @@
-M(a0 uint32, a1 uint32) Union(size: 5)
-M(a2 uint32, t3 uint32) Union(size: 5)
-M(t4 uint32, t5 uint32) Union(size: 5)
-M(a6 uint32, a7 uint32) Union(size: 5)
-M(S+0 uint32, S+4 uint32) Union(size: 5)
-M(S+8 uint32, S+12 uint32) Union(size: 5)
-M(S+16 uint32, S+20 uint32) Union(size: 5)
-M(S+24 uint32, S+28 uint32) Union(size: 5)
-M(S+32 uint32, S+36 uint32) Union(size: 5)
-M(S+40 uint32, S+44 uint32) Union(size: 5)
+M(a0 uint32, a1 uint32[uint8]) Union(size: 5)
+M(a2 uint32, t3 uint32[uint8]) Union(size: 5)
+M(t4 uint32, t5 uint32[uint8]) Union(size: 5)
+M(a6 uint32, a7 uint32[uint8]) Union(size: 5)
+M(S+0 uint32, S+4 uint32[uint8]) Union(size: 5)
+M(S+8 uint32, S+12 uint32[uint8]) Union(size: 5)
+M(S+16 uint32, S+20 uint32[uint8]) Union(size: 5)
+M(S+24 uint32, S+28 uint32[uint8]) Union(size: 5)
+M(S+32 uint32, S+36 uint32[uint8]) Union(size: 5)
+M(S+40 uint32, S+44 uint32[uint8]) Union(size: 5)
=>
-M(a0 uint32, a1 uint32) Union(size: 5)
+M(a0 uint32, a1 uint32[uint8]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv64_linux.expect
index d1eb35f..8c6dec6 100644
--- a/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/union5bytesPackedx10/riscv64_linux.expect
@@ -1,12 +1,12 @@
-M(a0 int64) Union(size: 5)
-M(a1 int64) Union(size: 5)
-M(a2 int64) Union(size: 5)
-M(t3 int64) Union(size: 5)
-M(t4 int64) Union(size: 5)
-M(t5 int64) Union(size: 5)
-M(a6 int64) Union(size: 5)
-M(a7 int64) Union(size: 5)
-M(S+0 int64) Union(size: 5)
-M(S+8 int64) Union(size: 5)
+M(a0 uint64[uint40]) Union(size: 5)
+M(a1 uint64[uint40]) Union(size: 5)
+M(a2 uint64[uint40]) Union(size: 5)
+M(t3 uint64[uint40]) Union(size: 5)
+M(t4 uint64[uint40]) Union(size: 5)
+M(t5 uint64[uint40]) Union(size: 5)
+M(a6 uint64[uint40]) Union(size: 5)
+M(a7 uint64[uint40]) Union(size: 5)
+M(S+0 uint64[uint40]) Union(size: 5)
+M(S+8 uint64[uint40]) Union(size: 5)
=>
-M(a0 int64) Union(size: 5)
+M(a0 uint64[uint40]) Union(size: 5)
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_android.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_android.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_android.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_fuchsia.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_fuchsia.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_fuchsia.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_fuchsia.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_ios.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_ios.expect
index ebee470..31988d3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_ios.expect
@@ -5,6 +5,6 @@
S+24 int64
S+32 int64
S+40 int64
-M(S+48 int64, S+56 int64) Struct(size: 12)
+M(S+48 uint64, S+56 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_linux.expect
index a2276ca..9311acb 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_linux.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(S+0 int64, S+8 int64) Struct(size: 12)
+M(S+0 uint64, S+8 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_macos.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_macos.expect
index ebee470..31988d3 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_macos.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_macos.expect
@@ -5,6 +5,6 @@
S+24 int64
S+32 int64
S+40 int64
-M(S+48 int64, S+56 int64) Struct(size: 12)
+M(S+48 uint64, S+56 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_win.expect
index 965436c..816bdb9 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm64_win.expect
@@ -5,6 +5,6 @@
r4 int64
r5 int64
r6 int64
-M(r7 int64, S+0 int64) Struct(size: 12)
+M(r7 uint64, S+0 uint64[uint32]) Struct(size: 12)
=>
r0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_android.expect
index 8e13dd5..30f16ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_android.expect
@@ -1,6 +1,6 @@
r0 int32
r1 int32
r2 int32
-M(r3 int32, S+0 int32) Struct(size: 6)
+M(r3 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
r0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_ios.expect
index 8e13dd5..30f16ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_ios.expect
@@ -1,6 +1,6 @@
r0 int32
r1 int32
r2 int32
-M(r3 int32, S+0 int32) Struct(size: 6)
+M(r3 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
r0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_linux.expect
index 8e13dd5..30f16ed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/arm_linux.expect
@@ -1,6 +1,6 @@
r0 int32
r1 int32
r2 int32
-M(r3 int32, S+0 int32) Struct(size: 6)
+M(r3 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
r0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv32_linux.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv32_linux.expect
index 540bf12..7cfe9f4 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv32_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv32_linux.expect
@@ -5,6 +5,6 @@
t4 int32
t5 int32
a6 int32
-M(a7 uint32, S+0 uint32) Struct(size: 6)
+M(a7 uint32, S+0 uint32[uint16]) Struct(size: 6)
=>
a0 int32
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv64_linux.expect
index 33930e4..7421b1b 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_stradle_last_register/riscv64_linux.expect
@@ -5,6 +5,6 @@
t4 int64
t5 int64
a6 int64
-M(a7 int64, S+0 int64) Struct(size: 12)
+M(a7 uint64, S+0 uint64[uint32]) Struct(size: 12)
=>
a0 int64
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm64_win.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm64_win.expect
index 76e12a7..2d85aed 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm64_win.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm64_win.expect
@@ -7,9 +7,9 @@
r6 int64[double]
r7 int64[double]
S+0 float
-M(S+8 int64, S+16 int64) Struct(size: 12)
+M(S+8 uint64, S+16 uint64[uint32]) Struct(size: 12)
S+24 int64
S+32 int32
-M(S+40 int64, S+48 int64) Struct(size: 12)
+M(S+40 uint64, S+48 uint64[uint32]) Struct(size: 12)
=>
v0 double
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_android.expect
index aad06e4..8d06c36 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_android.expect
@@ -7,9 +7,9 @@
S+32 double
S+40 double
S+48 float
-M(S+52 int32, S+56 int32, S+60 int32) Struct(size: 12)
+M(S+52 uint32, S+56 uint32, S+60 uint32) Struct(size: 12)
S+64 int64
S+72 int32
-M(S+76 int32, S+80 int32, S+84 int32) Struct(size: 12)
+M(S+76 uint32, S+80 uint32, S+84 uint32) Struct(size: 12)
=>
(r0, r1) int64[double]
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_ios.expect
index aad06e4..8d06c36 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_ios.expect
@@ -7,9 +7,9 @@
S+32 double
S+40 double
S+48 float
-M(S+52 int32, S+56 int32, S+60 int32) Struct(size: 12)
+M(S+52 uint32, S+56 uint32, S+60 uint32) Struct(size: 12)
S+64 int64
S+72 int32
-M(S+76 int32, S+80 int32, S+84 int32) Struct(size: 12)
+M(S+76 uint32, S+80 uint32, S+84 uint32) Struct(size: 12)
=>
(r0, r1) int64[double]
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_linux.expect
index aad06e4..8d06c36 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/arm_linux.expect
@@ -7,9 +7,9 @@
S+32 double
S+40 double
S+48 float
-M(S+52 int32, S+56 int32, S+60 int32) Struct(size: 12)
+M(S+52 uint32, S+56 uint32, S+60 uint32) Struct(size: 12)
S+64 int64
S+72 int32
-M(S+76 int32, S+80 int32, S+84 int32) Struct(size: 12)
+M(S+76 uint32, S+80 uint32, S+84 uint32) Struct(size: 12)
=>
(r0, r1) int64[double]
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/riscv64_linux.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/riscv64_linux.expect
index 7db8c75..dfdc2a9 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/riscv64_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_homogenous_struct/riscv64_linux.expect
@@ -7,9 +7,9 @@
fa6 double
fa7 double
a0 int32[float]
-M(a1 int64, a2 int64) Struct(size: 12)
+M(a1 uint64, a2 uint64[uint32]) Struct(size: 12)
t3 int64
t4 int32
-M(t5 int64, a6 int64) Struct(size: 12)
+M(t5 uint64, a6 uint64[uint32]) Struct(size: 12)
=>
fa0 double
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_android.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_android.expect
index 55f2bb8..7ad5675 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_android.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_android.expect
@@ -1,5 +1,5 @@
(r0, r1) int64[double]
-M(r2 int32, r3 int32, S+0 int32, S+4 int32, S+8 int32) Struct(size: 20)
+M(r2 uint32, r3 uint32, S+0 uint32, S+4 uint32, S+8 uint32) Struct(size: 20)
S+16 double
=>
(r0, r1) int64[double]
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_ios.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_ios.expect
index 55f2bb8..7ad5675 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_ios.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_ios.expect
@@ -1,5 +1,5 @@
(r0, r1) int64[double]
-M(r2 int32, r3 int32, S+0 int32, S+4 int32, S+8 int32) Struct(size: 20)
+M(r2 uint32, r3 uint32, S+0 uint32, S+4 uint32, S+8 uint32) Struct(size: 20)
S+16 double
=>
(r0, r1) int64[double]
diff --git a/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_linux.expect b/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_linux.expect
index 55f2bb8..7ad5675 100644
--- a/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_linux.expect
+++ b/runtime/vm/compiler/ffi/unit_tests/variadic_with_struct/arm_linux.expect
@@ -1,5 +1,5 @@
(r0, r1) int64[double]
-M(r2 int32, r3 int32, S+0 int32, S+4 int32, S+8 int32) Struct(size: 20)
+M(r2 uint32, r3 uint32, S+0 uint32, S+4 uint32, S+8 uint32) Struct(size: 20)
S+16 double
=>
(r0, r1) int64[double]
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index 16c3edf..c5b4b50 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -4607,26 +4607,6 @@
return body;
}
-Fragment FlowGraphBuilder::CopyFromCompoundToStack(
- LocalVariable* variable,
- const GrowableArray<Representation>& representations) {
- Fragment body;
- const intptr_t num_defs = representations.length();
- int offset_in_bytes = 0;
- for (intptr_t i = 0; i < num_defs; i++) {
- body += LoadLocal(variable);
- body += LoadTypedDataBaseFromCompound();
- body += LoadNativeField(Slot::PointerBase_data(),
- InnerPointerAccess::kMayBeInnerPointer);
- body += IntConstant(offset_in_bytes);
- const Representation representation = representations[i];
- offset_in_bytes += RepresentationUtils::ValueSize(representation);
- body += LoadIndexedTypedDataUnboxed(representation, /*index_scale=*/1,
- /*index_unboxed=*/false);
- }
- return body;
-}
-
Fragment FlowGraphBuilder::PopFromStackToTypedDataBase(
ZoneGrowableArray<LocalVariable*>* definitions,
const GrowableArray<Representation>& representations) {
@@ -4757,6 +4737,68 @@
return body;
}
+Fragment FlowGraphBuilder::LoadTail(LocalVariable* variable,
+ intptr_t size,
+ intptr_t offset_in_bytes,
+ Representation representation) {
+ Fragment body;
+ if (size == 8 || size == 4) {
+ body += LoadLocal(variable);
+ body += LoadTypedDataBaseFromCompound();
+ body += LoadNativeField(Slot::PointerBase_data(),
+ InnerPointerAccess::kMayBeInnerPointer);
+ body += IntConstant(offset_in_bytes);
+ body += LoadIndexedTypedDataUnboxed(representation, /*index_scale=*/1,
+ /*index_unboxed=*/false);
+ return body;
+ }
+ ASSERT(representation != kUnboxedFloat);
+ ASSERT(representation != kUnboxedDouble);
+ intptr_t shift = 0;
+ intptr_t remaining = size;
+ auto step = [&](intptr_t part_bytes, intptr_t part_cid) {
+ while (remaining >= part_bytes) {
+ body += LoadLocal(variable);
+ body += LoadTypedDataBaseFromCompound();
+ body += LoadNativeField(Slot::PointerBase_data(),
+ InnerPointerAccess::kMayBeInnerPointer);
+ body += IntConstant(offset_in_bytes);
+ body += LoadIndexed(part_cid, /*index_scale*/ 1,
+ /*index_unboxed=*/false);
+ if (shift != 0) {
+ body += IntConstant(shift);
+ // 64-bit doesn't support kUnboxedInt32 ops.
+ Representation op_representation = kUnboxedFfiIntPtr;
+ body += BinaryIntegerOp(Token::kSHL, op_representation,
+ /*is_truncating*/ true);
+ body += BinaryIntegerOp(Token::kBIT_OR, op_representation,
+ /*is_truncating*/ true);
+ }
+ offset_in_bytes += part_bytes;
+ remaining -= part_bytes;
+ shift += part_bytes * kBitsPerByte;
+ }
+ };
+ step(8, kTypedDataUint64ArrayCid);
+ step(4, kTypedDataUint32ArrayCid);
+ step(2, kTypedDataUint16ArrayCid);
+ step(1, kTypedDataUint8ArrayCid);
+
+ // Sigh, LoadIndex's representation for int8/16 is [u]int64, but the FfiCall
+ // wants an [u]int32 input. Manually insert a "truncating" conversion so one
+ // isn't automatically added that thinks it can deopt.
+ Representation from_representation = Peek(0)->representation();
+ if (from_representation != representation) {
+ IntConverterInstr* convert = new IntConverterInstr(
+ from_representation, representation, Pop(), DeoptId::kNone);
+ convert->mark_truncating();
+ Push(convert);
+ body <<= convert;
+ }
+
+ return body;
+}
+
Fragment FlowGraphBuilder::FfiCallConvertCompoundArgumentToNative(
LocalVariable* variable,
const compiler::ffi::BaseMarshaller& marshaller,
@@ -4778,21 +4820,25 @@
// 32 bits.
representation = loc.payload_type().AsRepresentationOverApprox(Z);
}
- body += LoadLocal(variable);
- body += LoadTypedDataBaseFromCompound();
- body += LoadNativeField(Slot::PointerBase_data(),
- InnerPointerAccess::kMayBeInnerPointer);
- body += IntConstant(offset_in_bytes);
- body += LoadIndexedTypedDataUnboxed(representation, /*index_scale=*/1,
- /*index_unboxed=*/false);
- offset_in_bytes += loc.payload_type().SizeInBytes();
+ intptr_t size = loc.payload_type().SizeInBytes();
+ body += LoadTail(variable, size, offset_in_bytes, representation);
+ offset_in_bytes += size;
}
} else if (native_loc.IsStack()) {
// Break struct in pieces to separate IL definitions to pass those
// separate definitions into the FFI call.
- GrowableArray<Representation> representations;
- marshaller.RepsInFfiCall(arg_index, &representations);
- body += CopyFromCompoundToStack(variable, representations);
+ Representation representation = kUnboxedWord;
+ intptr_t remaining = native_loc.payload_type().SizeInBytes();
+ intptr_t offset_in_bytes = 0;
+ while (remaining >= compiler::target::kWordSize) {
+ body += LoadTail(variable, compiler::target::kWordSize, offset_in_bytes,
+ representation);
+ offset_in_bytes += compiler::target::kWordSize;
+ remaining -= compiler::target::kWordSize;
+ }
+ if (remaining > 0) {
+ body += LoadTail(variable, remaining, offset_in_bytes, representation);
+ }
} else {
ASSERT(native_loc.IsPointerToMemory());
// Only load the typed data, do copying in the FFI call machine code.
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.h b/runtime/vm/compiler/frontend/kernel_to_il.h
index 1eb49f4..d01362b 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.h
+++ b/runtime/vm/compiler/frontend/kernel_to_il.h
@@ -338,6 +338,10 @@
// We pass in `variable` instead of on top of the stack so that we can have
// multiple consecutive calls that keep only compound parts on the stack with
// no compound parts in between.
+ Fragment LoadTail(LocalVariable* variable,
+ intptr_t size,
+ intptr_t offset_in_bytes,
+ Representation representation);
Fragment FfiCallConvertCompoundArgumentToNative(
LocalVariable* variable,
const compiler::ffi::BaseMarshaller& marshaller,
@@ -366,19 +370,6 @@
// Loads the _typedDataBase field from a subclass of _Compound.
Fragment LoadTypedDataBaseFromCompound();
- // Breaks up a subclass of _Compound in multiple definitions and puts them on
- // the stack.
- //
- // Takes in the _Compound as a local `variable` so that can be anywhere on
- // the stack and this function can be called multiple times to leave only the
- // results of this function on the stack without any _Compounds in between.
- //
- // The compound contents are heterogeneous, so pass in
- // `representations` to know what representation to load.
- Fragment CopyFromCompoundToStack(
- LocalVariable* variable,
- const GrowableArray<Representation>& representations);
-
// Copy `definitions` into TypedData.
//
// Expects the TypedData on top of the stack and `definitions` right under it.
diff --git a/tests/ffi/ffi.status b/tests/ffi/ffi.status
index 1e7bf99..188dfc9 100644
--- a/tests/ffi/ffi.status
+++ b/tests/ffi/ffi.status
@@ -42,9 +42,6 @@
[ $mode == product ]
regress_47594_test: Skip # Profiler is not available in Product.
-[ $runtime == vm ]
-function_struct_by_value_out_of_bounds_test: Crash # https://github.com/dart-lang/sdk/issues/53829
-
[ $system == android ]
*: Pass, Slow # https://github.com/dart-lang/sdk/issues/38489
regress_47594_test: Skip # DartDev is not available on Android.
diff --git a/tests/ffi/function_struct_by_value_out_of_bounds_test.dart b/tests/ffi/function_struct_by_value_out_of_bounds_test.dart
index d12bc9c..75c90e2 100644
--- a/tests/ffi/function_struct_by_value_out_of_bounds_test.dart
+++ b/tests/ffi/function_struct_by_value_out_of_bounds_test.dart
@@ -42,6 +42,11 @@
'(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})';
}
+typedef Callback = Struct9Uint8 Function(Pointer<Struct9Uint8> s9);
+Struct9Uint8 returnStruct9(Pointer<Struct9Uint8> s9) {
+ return s9.ref;
+}
+
void main() {
final ffiTestFunctions = dlopenPlatformSpecific('ffi_test_functions');
final alloc = ffiTestFunctions.lookupFunction<
@@ -49,12 +54,17 @@
Pointer<Struct9Uint8> Function()>('AllocStruct9Uint8');
final sum = ffiTestFunctions.lookupFunction<Int64 Function(Struct9Uint8),
int Function(Struct9Uint8)>('SumStruct9Uint8');
+ final sumReturnStruct9 = ffiTestFunctions.lookupFunction<
+ Int64 Function(Pointer<NativeFunction<Callback>>, Pointer<Struct9Uint8>),
+ int Function(Pointer<NativeFunction<Callback>>,
+ Pointer<Struct9Uint8>)>('SumReturnStruct9Uint8');
final free = ffiTestFunctions.lookupFunction<
Void Function(Pointer<Struct9Uint8>),
void Function(Pointer<Struct9Uint8>)>('FreeStruct9Uint8');
final array = alloc();
Struct9Uint8 s9 = array[64 * 1024 - 1]; // At the end of a page.
+ Pointer<Struct9Uint8> s9Pointer = array.elementAt(64 * 1024 - 1);
s9.a0 = 1;
s9.a1 = 2;
@@ -70,7 +80,11 @@
// marshaller must not access the last member as a full word load, which could
// fault.
int result = sum(s9);
+ Expect.equals(45, result);
+ // Also on the return path.
+ final callback = Pointer.fromFunction<Callback>(returnStruct9);
+ result = sumReturnStruct9(callback, s9Pointer);
Expect.equals(45, result);
free(array);
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index 24d2ea2..5b2ec4e 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -1778,7 +1778,8 @@
"vm-win-release-arm64"
],
"meta": {
- "description": "This configuration is for the ARM64 JIT builders, no shards."
+ "description": "This configuration is for the ARM64 JIT builders, no shards.",
+ "__comment__": "--no-clang because Clang is inconsisent about varargs: dartbug.com/52644"
},
"steps": [
{
@@ -1786,6 +1787,7 @@
"script": "tools/build.py",
"arguments": [
"--no-goma",
+ "--no-clang",
"runtime"
]
},
@@ -1811,7 +1813,8 @@
"vm-aot-win-release-arm64"
],
"meta": {
- "description": "This configuration is for the ARM64 AOT builders, no shards."
+ "description": "This configuration is for the ARM64 AOT builders, no shards.",
+ "__comment__": "--no-clang because Clang is inconsisent about varargs: dartbug.com/52644"
},
"steps": [
{
@@ -1819,6 +1822,7 @@
"script": "tools/build.py",
"arguments": [
"--no-goma",
+ "--no-clang",
"dart_precompiled_runtime",
"gen_snapshot",
"runtime"
