mirror of
https://github.com/dart-lang/sdk
synced 2024-10-14 09:43:57 +00:00
c0b938c228
Non-variadic arguments on the stack on MacOS Arm64 are aligned to the value size (which can be smaller than word size). However, for varargs, the arguments on the stack seem to be aligned to the word size. This CL introduces an alignment strategy constant for primitives on the stack in varargs and uses it in the native calling convention calculation. TEST=runtime/vm/compiler/ffi/native_calling_convention_test.cc with runtime/vm/compiler/ffi/unit_tests/variadic_less_than_word/arm64_macos.expect TEST=tests/ffi/function_varargs_generated_native_leaf_test.dart Closes: https://github.com/dart-lang/sdk/issues/55471 Change-Id: I51d20c3933a2cea9b110954ddec92fb91b9c3ecd Cq-Include-Trybots: dart/try:vm-aot-android-release-arm64c-try,vm-aot-linux-debug-x64-try,vm-aot-linux-debug-x64c-try,vm-aot-mac-release-arm64-try,vm-aot-mac-release-x64-try,vm-aot-obfuscate-linux-release-x64-try,vm-aot-optimization-level-linux-release-x64-try,vm-aot-win-debug-arm64-try,vm-aot-win-debug-x64-try,vm-aot-win-debug-x64c-try,vm-appjit-linux-debug-x64-try,vm-asan-linux-release-x64-try,vm-checked-mac-release-arm64-try,vm-eager-optimization-linux-release-ia32-try,vm-eager-optimization-linux-release-x64-try,vm-ffi-android-debug-arm-try,vm-ffi-android-debug-arm64c-try,vm-ffi-qemu-linux-release-arm-try,vm-ffi-qemu-linux-release-riscv64-try,vm-fuchsia-release-x64-try,vm-linux-debug-ia32-try,vm-linux-debug-x64-try,vm-linux-debug-x64c-try,vm-mac-debug-arm64-try,vm-mac-debug-x64-try,vm-msan-linux-release-x64-try,vm-reload-linux-debug-x64-try,vm-reload-rollback-linux-debug-x64-try,vm-ubsan-linux-release-x64-try,vm-win-debug-arm64-try,vm-win-debug-x64-try,vm-win-debug-x64c-try,vm-win-release-ia32-try Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/362762 Commit-Queue: Daco Harkes <dacoharkes@google.com> Reviewed-by: Tess Strickland <sstrickl@google.com>
843 lines
20 KiB
Dart
843 lines
20 KiB
Dart
// Copyright (c) 2023, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
//
|
|
// This file has been automatically generated. Please do not edit it manually.
|
|
// Generated by tests/ffi/generator/structs_by_value_tests_generator.dart.
|
|
//
|
|
// SharedObjects=ffi_test_functions
|
|
// VMOptions=
|
|
// VMOptions=--deterministic --optimization-counter-threshold=90
|
|
// VMOptions=--use-slow-path
|
|
// VMOptions=--use-slow-path --stacktrace-every=100
|
|
|
|
import 'dart:ffi';
|
|
|
|
import 'package:expect/expect.dart';
|
|
// ignore: unused_import
|
|
import 'package:ffi/ffi.dart';
|
|
|
|
import 'dylib_utils.dart';
|
|
|
|
// Reuse the compound classes.
|
|
import 'function_structs_by_value_generated_compounds.dart';
|
|
|
|
final ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");
|
|
void main() {
|
|
for (int i = 0; i < 100; ++i) {
|
|
testVariadicAt1Int64x2Leaf();
|
|
testVariadicAt1Doublex2Leaf();
|
|
testVariadicAt1Int64x5Leaf();
|
|
testVariadicAt1Doublex5Leaf();
|
|
testVariadicAt1Int64x20Leaf();
|
|
testVariadicAt1Doublex20Leaf();
|
|
testVariadicAt1Int64x2Struct8BytesIntInt64Leaf();
|
|
testVariadicAt1Doublex2Struct32BytesHomogeneousDoubleDLeaf();
|
|
testVariadicAt1DoubleStruct12BytesHomogeneousFloatDoubLeaf();
|
|
testVariadicAt1Int32Struct20BytesHomogeneousInt32Int32Leaf();
|
|
testVariadicAt1DoubleStruct20BytesHomogeneousFloatDoubLeaf();
|
|
testVariadicAt2Int32Int64IntPtrLeaf();
|
|
testVariadicAt1DoubleInt64Int32DoubleInt64Int32Leaf();
|
|
testVariadicAt1Int64Int32Struct12BytesHomogeneousFloatLeaf();
|
|
testVariadicAt11Doublex8FloatStruct12BytesHomogeneousFLeaf();
|
|
testVariadicAt1DoubleInt64Int32Struct20BytesHomogeneouLeaf();
|
|
testVariadicAt5Doublex5Leaf();
|
|
testVariadicAt1Int64x7Struct12BytesHomogeneousInt32Leaf();
|
|
testVariadicAt1Struct12BytesHomogeneousInt32Int32x4Leaf();
|
|
}
|
|
}
|
|
|
|
final variadicAt1Int64x2Leaf = ffiTestFunctions.lookupFunction<
|
|
Int64 Function(Int64, VarArgs<(Int64,)>),
|
|
int Function(int, int)>("VariadicAt1Int64x2", isLeaf: true);
|
|
|
|
/// Single variadic argument.
|
|
void testVariadicAt1Int64x2Leaf() {
|
|
int a0;
|
|
int a1;
|
|
|
|
a0 = -1;
|
|
a1 = 2;
|
|
|
|
final result = variadicAt1Int64x2Leaf(a0, a1);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(1, result);
|
|
}
|
|
|
|
final variadicAt1Doublex2Leaf = ffiTestFunctions.lookupFunction<
|
|
Double Function(Double, VarArgs<(Double,)>),
|
|
double Function(double, double)>("VariadicAt1Doublex2", isLeaf: true);
|
|
|
|
/// Single variadic argument.
|
|
void testVariadicAt1Doublex2Leaf() {
|
|
double a0;
|
|
double a1;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2.0;
|
|
|
|
final result = variadicAt1Doublex2Leaf(a0, a1);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(1.0, result);
|
|
}
|
|
|
|
final variadicAt1Int64x5Leaf = ffiTestFunctions.lookupFunction<
|
|
Int64 Function(Int64, VarArgs<(Int64, Int64, Int64, Int64)>),
|
|
int Function(int, int, int, int, int)>("VariadicAt1Int64x5", isLeaf: true);
|
|
|
|
/// Variadic arguments.
|
|
void testVariadicAt1Int64x5Leaf() {
|
|
int a0;
|
|
int a1;
|
|
int a2;
|
|
int a3;
|
|
int a4;
|
|
|
|
a0 = -1;
|
|
a1 = 2;
|
|
a2 = -3;
|
|
a3 = 4;
|
|
a4 = -5;
|
|
|
|
final result = variadicAt1Int64x5Leaf(a0, a1, a2, a3, a4);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(-3, result);
|
|
}
|
|
|
|
final variadicAt1Doublex5Leaf = ffiTestFunctions.lookupFunction<
|
|
Double Function(Double, VarArgs<(Double, Double, Double, Double)>),
|
|
double Function(double, double, double, double,
|
|
double)>("VariadicAt1Doublex5", isLeaf: true);
|
|
|
|
/// Variadic arguments.
|
|
void testVariadicAt1Doublex5Leaf() {
|
|
double a0;
|
|
double a1;
|
|
double a2;
|
|
double a3;
|
|
double a4;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2.0;
|
|
a2 = -3.0;
|
|
a3 = 4.0;
|
|
a4 = -5.0;
|
|
|
|
final result = variadicAt1Doublex5Leaf(a0, a1, a2, a3, a4);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-3.0, result);
|
|
}
|
|
|
|
final variadicAt1Int64x20Leaf = ffiTestFunctions.lookupFunction<
|
|
Int64 Function(
|
|
Int64,
|
|
VarArgs<
|
|
(
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64
|
|
)>),
|
|
int Function(
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int,
|
|
int)>("VariadicAt1Int64x20", isLeaf: true);
|
|
|
|
/// Variadic arguments exhaust registers.
|
|
void testVariadicAt1Int64x20Leaf() {
|
|
int a0;
|
|
int a1;
|
|
int a2;
|
|
int a3;
|
|
int a4;
|
|
int a5;
|
|
int a6;
|
|
int a7;
|
|
int a8;
|
|
int a9;
|
|
int a10;
|
|
int a11;
|
|
int a12;
|
|
int a13;
|
|
int a14;
|
|
int a15;
|
|
int a16;
|
|
int a17;
|
|
int a18;
|
|
int a19;
|
|
|
|
a0 = -1;
|
|
a1 = 2;
|
|
a2 = -3;
|
|
a3 = 4;
|
|
a4 = -5;
|
|
a5 = 6;
|
|
a6 = -7;
|
|
a7 = 8;
|
|
a8 = -9;
|
|
a9 = 10;
|
|
a10 = -11;
|
|
a11 = 12;
|
|
a12 = -13;
|
|
a13 = 14;
|
|
a14 = -15;
|
|
a15 = 16;
|
|
a16 = -17;
|
|
a17 = 18;
|
|
a18 = -19;
|
|
a19 = 20;
|
|
|
|
final result = variadicAt1Int64x20Leaf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
|
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(10, result);
|
|
}
|
|
|
|
final variadicAt1Doublex20Leaf = ffiTestFunctions.lookupFunction<
|
|
Double Function(
|
|
Double,
|
|
VarArgs<
|
|
(
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double
|
|
)>),
|
|
double Function(
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double)>("VariadicAt1Doublex20", isLeaf: true);
|
|
|
|
/// Variadic arguments exhaust registers.
|
|
void testVariadicAt1Doublex20Leaf() {
|
|
double a0;
|
|
double a1;
|
|
double a2;
|
|
double a3;
|
|
double a4;
|
|
double a5;
|
|
double a6;
|
|
double a7;
|
|
double a8;
|
|
double a9;
|
|
double a10;
|
|
double a11;
|
|
double a12;
|
|
double a13;
|
|
double a14;
|
|
double a15;
|
|
double a16;
|
|
double a17;
|
|
double a18;
|
|
double a19;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2.0;
|
|
a2 = -3.0;
|
|
a3 = 4.0;
|
|
a4 = -5.0;
|
|
a5 = 6.0;
|
|
a6 = -7.0;
|
|
a7 = 8.0;
|
|
a8 = -9.0;
|
|
a9 = 10.0;
|
|
a10 = -11.0;
|
|
a11 = 12.0;
|
|
a12 = -13.0;
|
|
a13 = 14.0;
|
|
a14 = -15.0;
|
|
a15 = 16.0;
|
|
a16 = -17.0;
|
|
a17 = 18.0;
|
|
a18 = -19.0;
|
|
a19 = 20.0;
|
|
|
|
final result = variadicAt1Doublex20Leaf(a0, a1, a2, a3, a4, a5, a6, a7, a8,
|
|
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(10.0, result);
|
|
}
|
|
|
|
final variadicAt1Int64x2Struct8BytesIntInt64Leaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Int64 Function(Int64, VarArgs<(Int64, Struct8BytesInt, Int64)>),
|
|
int Function(int, int, Struct8BytesInt,
|
|
int)>("VariadicAt1Int64x2Struct8BytesIntInt64", isLeaf: true);
|
|
|
|
/// Variadic arguments including struct.
|
|
void testVariadicAt1Int64x2Struct8BytesIntInt64Leaf() {
|
|
int a0;
|
|
int a1;
|
|
final a2Pointer = calloc<Struct8BytesInt>();
|
|
final Struct8BytesInt a2 = a2Pointer.ref;
|
|
int a3;
|
|
|
|
a0 = -1;
|
|
a1 = 2;
|
|
a2.a0 = -3;
|
|
a2.a1 = 4;
|
|
a2.a2 = -5;
|
|
a3 = 6;
|
|
|
|
final result = variadicAt1Int64x2Struct8BytesIntInt64Leaf(a0, a1, a2, a3);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(3, result);
|
|
|
|
calloc.free(a2Pointer);
|
|
}
|
|
|
|
final variadicAt1Doublex2Struct32BytesHomogeneousDoubleDLeaf = ffiTestFunctions
|
|
.lookupFunction<
|
|
Double Function(Double,
|
|
VarArgs<(Double, Struct32BytesHomogeneousDouble, Double)>),
|
|
double Function(
|
|
double, double, Struct32BytesHomogeneousDouble, double)>(
|
|
"VariadicAt1Doublex2Struct32BytesHomogeneousDoubleD",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments including struct.
|
|
void testVariadicAt1Doublex2Struct32BytesHomogeneousDoubleDLeaf() {
|
|
double a0;
|
|
double a1;
|
|
final a2Pointer = calloc<Struct32BytesHomogeneousDouble>();
|
|
final Struct32BytesHomogeneousDouble a2 = a2Pointer.ref;
|
|
double a3;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2.0;
|
|
a2.a0 = -3.0;
|
|
a2.a1 = 4.0;
|
|
a2.a2 = -5.0;
|
|
a2.a3 = 6.0;
|
|
a3 = -7.0;
|
|
|
|
final result =
|
|
variadicAt1Doublex2Struct32BytesHomogeneousDoubleDLeaf(a0, a1, a2, a3);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-4.0, result);
|
|
|
|
calloc.free(a2Pointer);
|
|
}
|
|
|
|
final variadicAt1DoubleStruct12BytesHomogeneousFloatDoubLeaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Double Function(
|
|
Double, VarArgs<(Struct12BytesHomogeneousFloat, Double)>),
|
|
double Function(double, Struct12BytesHomogeneousFloat, double)>(
|
|
"VariadicAt1DoubleStruct12BytesHomogeneousFloatDoub",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments including struct.
|
|
void testVariadicAt1DoubleStruct12BytesHomogeneousFloatDoubLeaf() {
|
|
double a0;
|
|
final a1Pointer = calloc<Struct12BytesHomogeneousFloat>();
|
|
final Struct12BytesHomogeneousFloat a1 = a1Pointer.ref;
|
|
double a2;
|
|
|
|
a0 = -1.0;
|
|
a1.a0 = 2.0;
|
|
a1.a1 = -3.0;
|
|
a1.a2 = 4.0;
|
|
a2 = -5.0;
|
|
|
|
final result =
|
|
variadicAt1DoubleStruct12BytesHomogeneousFloatDoubLeaf(a0, a1, a2);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-3.0, result);
|
|
|
|
calloc.free(a1Pointer);
|
|
}
|
|
|
|
final variadicAt1Int32Struct20BytesHomogeneousInt32Int32Leaf =
|
|
ffiTestFunctions
|
|
.lookupFunction<
|
|
Int32 Function(
|
|
Int32, VarArgs<(Struct20BytesHomogeneousInt32, Int32)>),
|
|
int Function(int, Struct20BytesHomogeneousInt32, int)>(
|
|
"VariadicAt1Int32Struct20BytesHomogeneousInt32Int32",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments including struct.
|
|
void testVariadicAt1Int32Struct20BytesHomogeneousInt32Int32Leaf() {
|
|
int a0;
|
|
final a1Pointer = calloc<Struct20BytesHomogeneousInt32>();
|
|
final Struct20BytesHomogeneousInt32 a1 = a1Pointer.ref;
|
|
int a2;
|
|
|
|
a0 = -1;
|
|
a1.a0 = 2;
|
|
a1.a1 = -3;
|
|
a1.a2 = 4;
|
|
a1.a3 = -5;
|
|
a1.a4 = 6;
|
|
a2 = -7;
|
|
|
|
final result =
|
|
variadicAt1Int32Struct20BytesHomogeneousInt32Int32Leaf(a0, a1, a2);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(-4, result);
|
|
|
|
calloc.free(a1Pointer);
|
|
}
|
|
|
|
final variadicAt1DoubleStruct20BytesHomogeneousFloatDoubLeaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Double Function(
|
|
Double, VarArgs<(Struct20BytesHomogeneousFloat, Double)>),
|
|
double Function(double, Struct20BytesHomogeneousFloat, double)>(
|
|
"VariadicAt1DoubleStruct20BytesHomogeneousFloatDoub",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments including struct.
|
|
void testVariadicAt1DoubleStruct20BytesHomogeneousFloatDoubLeaf() {
|
|
double a0;
|
|
final a1Pointer = calloc<Struct20BytesHomogeneousFloat>();
|
|
final Struct20BytesHomogeneousFloat a1 = a1Pointer.ref;
|
|
double a2;
|
|
|
|
a0 = -1.0;
|
|
a1.a0 = 2.0;
|
|
a1.a1 = -3.0;
|
|
a1.a2 = 4.0;
|
|
a1.a3 = -5.0;
|
|
a1.a4 = 6.0;
|
|
a2 = -7.0;
|
|
|
|
final result =
|
|
variadicAt1DoubleStruct20BytesHomogeneousFloatDoubLeaf(a0, a1, a2);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-4.0, result);
|
|
|
|
calloc.free(a1Pointer);
|
|
}
|
|
|
|
final variadicAt2Int32Int64IntPtrLeaf = ffiTestFunctions.lookupFunction<
|
|
Int32 Function(Int32, Int64, VarArgs<(IntPtr,)>),
|
|
int Function(int, int, int)>("VariadicAt2Int32Int64IntPtr", isLeaf: true);
|
|
|
|
/// Regression test for variadic arguments.
|
|
/// https://github.com/dart-lang/sdk/issues/49460
|
|
void testVariadicAt2Int32Int64IntPtrLeaf() {
|
|
int a0;
|
|
int a1;
|
|
int a2;
|
|
|
|
a0 = -1;
|
|
a1 = 2;
|
|
a2 = -3;
|
|
|
|
final result = variadicAt2Int32Int64IntPtrLeaf(a0, a1, a2);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(-2, result);
|
|
}
|
|
|
|
final variadicAt1DoubleInt64Int32DoubleInt64Int32Leaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Double Function(Double, VarArgs<(Int64, Int32, Double, Int64, Int32)>),
|
|
double Function(double, int, int, double, int,
|
|
int)>("VariadicAt1DoubleInt64Int32DoubleInt64Int32", isLeaf: true);
|
|
|
|
/// Variadic arguments mixed.
|
|
void testVariadicAt1DoubleInt64Int32DoubleInt64Int32Leaf() {
|
|
double a0;
|
|
int a1;
|
|
int a2;
|
|
double a3;
|
|
int a4;
|
|
int a5;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2;
|
|
a2 = -3;
|
|
a3 = 4.0;
|
|
a4 = -5;
|
|
a5 = 6;
|
|
|
|
final result =
|
|
variadicAt1DoubleInt64Int32DoubleInt64Int32Leaf(a0, a1, a2, a3, a4, a5);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(3.0, result);
|
|
}
|
|
|
|
final variadicAt1Int64Int32Struct12BytesHomogeneousFloatLeaf =
|
|
ffiTestFunctions
|
|
.lookupFunction<
|
|
Double Function(
|
|
Int64, VarArgs<(Int32, Struct12BytesHomogeneousFloat)>),
|
|
double Function(int, int, Struct12BytesHomogeneousFloat)>(
|
|
"VariadicAt1Int64Int32Struct12BytesHomogeneousFloat",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments homogenous struct stack alignment on macos_arm64.
|
|
void testVariadicAt1Int64Int32Struct12BytesHomogeneousFloatLeaf() {
|
|
int a0;
|
|
int a1;
|
|
final a2Pointer = calloc<Struct12BytesHomogeneousFloat>();
|
|
final Struct12BytesHomogeneousFloat a2 = a2Pointer.ref;
|
|
|
|
a0 = -1;
|
|
a1 = 2;
|
|
a2.a0 = -3.0;
|
|
a2.a1 = 4.0;
|
|
a2.a2 = -5.0;
|
|
|
|
final result =
|
|
variadicAt1Int64Int32Struct12BytesHomogeneousFloatLeaf(a0, a1, a2);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-3.0, result);
|
|
|
|
calloc.free(a2Pointer);
|
|
}
|
|
|
|
final variadicAt11Doublex8FloatStruct12BytesHomogeneousFLeaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Double Function(
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Float,
|
|
Struct12BytesHomogeneousFloat,
|
|
Int64,
|
|
VarArgs<(Int32, Struct12BytesHomogeneousFloat)>),
|
|
double Function(
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
double,
|
|
Struct12BytesHomogeneousFloat,
|
|
int,
|
|
int,
|
|
Struct12BytesHomogeneousFloat)>(
|
|
"VariadicAt11Doublex8FloatStruct12BytesHomogeneousF",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments homogenous struct stack alignment on macos_arm64.
|
|
void testVariadicAt11Doublex8FloatStruct12BytesHomogeneousFLeaf() {
|
|
double a0;
|
|
double a1;
|
|
double a2;
|
|
double a3;
|
|
double a4;
|
|
double a5;
|
|
double a6;
|
|
double a7;
|
|
double a8;
|
|
final a9Pointer = calloc<Struct12BytesHomogeneousFloat>();
|
|
final Struct12BytesHomogeneousFloat a9 = a9Pointer.ref;
|
|
int a10;
|
|
int a11;
|
|
final a12Pointer = calloc<Struct12BytesHomogeneousFloat>();
|
|
final Struct12BytesHomogeneousFloat a12 = a12Pointer.ref;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2.0;
|
|
a2 = -3.0;
|
|
a3 = 4.0;
|
|
a4 = -5.0;
|
|
a5 = 6.0;
|
|
a6 = -7.0;
|
|
a7 = 8.0;
|
|
a8 = -9.0;
|
|
a9.a0 = 10.0;
|
|
a9.a1 = -11.0;
|
|
a9.a2 = 12.0;
|
|
a10 = -13;
|
|
a11 = 14;
|
|
a12.a0 = -15.0;
|
|
a12.a1 = 16.0;
|
|
a12.a2 = -17.0;
|
|
|
|
final result = variadicAt11Doublex8FloatStruct12BytesHomogeneousFLeaf(
|
|
a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-9.0, result);
|
|
|
|
calloc.free(a9Pointer);
|
|
calloc.free(a12Pointer);
|
|
}
|
|
|
|
final variadicAt1DoubleInt64Int32Struct20BytesHomogeneouLeaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Double Function(
|
|
Double,
|
|
VarArgs<
|
|
(
|
|
Int64,
|
|
Int32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Double,
|
|
Int64,
|
|
Int32,
|
|
Struct12BytesHomogeneousFloat,
|
|
Int64
|
|
)>),
|
|
double Function(
|
|
double,
|
|
int,
|
|
int,
|
|
Struct20BytesHomogeneousInt32,
|
|
double,
|
|
int,
|
|
int,
|
|
Struct12BytesHomogeneousFloat,
|
|
int)>("VariadicAt1DoubleInt64Int32Struct20BytesHomogeneou",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments mixed.
|
|
void testVariadicAt1DoubleInt64Int32Struct20BytesHomogeneouLeaf() {
|
|
double a0;
|
|
int a1;
|
|
int a2;
|
|
final a3Pointer = calloc<Struct20BytesHomogeneousInt32>();
|
|
final Struct20BytesHomogeneousInt32 a3 = a3Pointer.ref;
|
|
double a4;
|
|
int a5;
|
|
int a6;
|
|
final a7Pointer = calloc<Struct12BytesHomogeneousFloat>();
|
|
final Struct12BytesHomogeneousFloat a7 = a7Pointer.ref;
|
|
int a8;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2;
|
|
a2 = -3;
|
|
a3.a0 = 4;
|
|
a3.a1 = -5;
|
|
a3.a2 = 6;
|
|
a3.a3 = -7;
|
|
a3.a4 = 8;
|
|
a4 = -9.0;
|
|
a5 = 10;
|
|
a6 = -11;
|
|
a7.a0 = 12.0;
|
|
a7.a1 = -13.0;
|
|
a7.a2 = 14.0;
|
|
a8 = -15;
|
|
|
|
final result = variadicAt1DoubleInt64Int32Struct20BytesHomogeneouLeaf(
|
|
a0, a1, a2, a3, a4, a5, a6, a7, a8);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-8.0, result);
|
|
|
|
calloc.free(a3Pointer);
|
|
calloc.free(a7Pointer);
|
|
}
|
|
|
|
final variadicAt5Doublex5Leaf = ffiTestFunctions.lookupFunction<
|
|
Double Function(Double, Double, Double, Double, Double, VarArgs<()>),
|
|
double Function(double, double, double, double,
|
|
double)>("VariadicAt5Doublex5", isLeaf: true);
|
|
|
|
/// Variadic arguments function definition, but not passing any.
|
|
void testVariadicAt5Doublex5Leaf() {
|
|
double a0;
|
|
double a1;
|
|
double a2;
|
|
double a3;
|
|
double a4;
|
|
|
|
a0 = -1.0;
|
|
a1 = 2.0;
|
|
a2 = -3.0;
|
|
a3 = 4.0;
|
|
a4 = -5.0;
|
|
|
|
final result = variadicAt5Doublex5Leaf(a0, a1, a2, a3, a4);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.approxEquals(-3.0, result);
|
|
}
|
|
|
|
final variadicAt1Int64x7Struct12BytesHomogeneousInt32Leaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Int64 Function(
|
|
Int64,
|
|
VarArgs<
|
|
(
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Int64,
|
|
Struct12BytesHomogeneousInt32
|
|
)>),
|
|
int Function(int, int, int, int, int, int, int,
|
|
Struct12BytesHomogeneousInt32)>(
|
|
"VariadicAt1Int64x7Struct12BytesHomogeneousInt32",
|
|
isLeaf: true);
|
|
|
|
/// Struct stradles last argument register, variadic
|
|
void testVariadicAt1Int64x7Struct12BytesHomogeneousInt32Leaf() {
|
|
int a0;
|
|
int a1;
|
|
int a2;
|
|
int a3;
|
|
int a4;
|
|
int a5;
|
|
int a6;
|
|
final a7Pointer = calloc<Struct12BytesHomogeneousInt32>();
|
|
final Struct12BytesHomogeneousInt32 a7 = a7Pointer.ref;
|
|
|
|
a0 = -1;
|
|
a1 = 2;
|
|
a2 = -3;
|
|
a3 = 4;
|
|
a4 = -5;
|
|
a5 = 6;
|
|
a6 = -7;
|
|
a7.a0 = 8;
|
|
a7.a1 = -9;
|
|
a7.a2 = 10;
|
|
|
|
final result = variadicAt1Int64x7Struct12BytesHomogeneousInt32Leaf(
|
|
a0, a1, a2, a3, a4, a5, a6, a7);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(5, result);
|
|
|
|
calloc.free(a7Pointer);
|
|
}
|
|
|
|
final variadicAt1Struct12BytesHomogeneousInt32Int32x4Leaf =
|
|
ffiTestFunctions.lookupFunction<
|
|
Int32 Function(Struct12BytesHomogeneousInt32,
|
|
VarArgs<(Int32, Int32, Int32, Int32)>),
|
|
int Function(Struct12BytesHomogeneousInt32, int, int, int, int)>(
|
|
"VariadicAt1Struct12BytesHomogeneousInt32Int32x4",
|
|
isLeaf: true);
|
|
|
|
/// Variadic arguments test on macos_arm64.
|
|
void testVariadicAt1Struct12BytesHomogeneousInt32Int32x4Leaf() {
|
|
final a0Pointer = calloc<Struct12BytesHomogeneousInt32>();
|
|
final Struct12BytesHomogeneousInt32 a0 = a0Pointer.ref;
|
|
int a1;
|
|
int a2;
|
|
int a3;
|
|
int a4;
|
|
|
|
a0.a0 = -1;
|
|
a0.a1 = 2;
|
|
a0.a2 = -3;
|
|
a1 = 4;
|
|
a2 = -5;
|
|
a3 = 6;
|
|
a4 = -7;
|
|
|
|
final result =
|
|
variadicAt1Struct12BytesHomogeneousInt32Int32x4Leaf(a0, a1, a2, a3, a4);
|
|
|
|
print("result = $result");
|
|
|
|
Expect.equals(-4, result);
|
|
|
|
calloc.free(a0Pointer);
|
|
}
|