| // 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() { |
| // Force dlopen so @Native lookups in DynamicLibrary.process() succeed. |
| dlopenGlobalPlatformSpecific('ffi_test_functions'); |
| |
| for (int i = 0; i < 100; ++i) { |
| testPassStruct1ByteIntx10NativeLeaf(); |
| testPassStruct3BytesHomogeneousUint8x10NativeLeaf(); |
| testPassStruct3BytesInt2ByteAlignedx10NativeLeaf(); |
| testPassStruct4BytesHomogeneousInt16x10NativeLeaf(); |
| testPassStruct7BytesHomogeneousUint8x10NativeLeaf(); |
| testPassStruct7BytesInt4ByteAlignedx10NativeLeaf(); |
| testPassStruct8BytesIntx10NativeLeaf(); |
| testPassStruct8BytesHomogeneousFloatx10NativeLeaf(); |
| testPassStruct8BytesMixedx10NativeLeaf(); |
| testPassStruct9BytesHomogeneousUint8x10NativeLeaf(); |
| testPassStruct9BytesInt4Or8ByteAlignedx10NativeLeaf(); |
| testPassStruct12BytesHomogeneousFloatx6NativeLeaf(); |
| testPassStruct16BytesHomogeneousFloatx5NativeLeaf(); |
| testPassStruct16BytesMixedx10NativeLeaf(); |
| testPassStruct16BytesMixed2x10NativeLeaf(); |
| testPassStruct17BytesIntx10NativeLeaf(); |
| testPassStruct19BytesHomogeneousUint8x10NativeLeaf(); |
| testPassStruct20BytesHomogeneousInt32x10NativeLeaf(); |
| testPassStruct20BytesHomogeneousFloatNativeLeaf(); |
| testPassStruct32BytesHomogeneousDoublex5NativeLeaf(); |
| testPassStruct40BytesHomogeneousDoubleNativeLeaf(); |
| testPassStruct1024BytesHomogeneousUint64NativeLeaf(); |
| testPassFloatStruct16BytesHomogeneousFloatFloatStruct1NativeLeaf(); |
| testPassFloatStruct32BytesHomogeneousDoubleFloatStructNativeLeaf(); |
| testPassInt8Struct16BytesMixedInt8Struct16BytesMixedInNativeLeaf(); |
| testPassDoublex6Struct16BytesMixedx4Int32NativeLeaf(); |
| testPassInt32x4Struct16BytesMixedx4DoubleNativeLeaf(); |
| testPassStruct40BytesHomogeneousDoubleStruct4BytesHomoNativeLeaf(); |
| testPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntNativeLeaf(); |
| testPassStructAlignmentInt16NativeLeaf(); |
| testPassStructAlignmentInt32NativeLeaf(); |
| testPassStructAlignmentInt64NativeLeaf(); |
| testPassStruct8BytesNestedIntx10NativeLeaf(); |
| testPassStruct8BytesNestedFloatx10NativeLeaf(); |
| testPassStruct8BytesNestedFloat2x10NativeLeaf(); |
| testPassStruct8BytesNestedMixedx10NativeLeaf(); |
| testPassStruct16BytesNestedIntx2NativeLeaf(); |
| testPassStruct32BytesNestedIntx2NativeLeaf(); |
| testPassStructNestedIntStructAlignmentInt16NativeLeaf(); |
| testPassStructNestedIntStructAlignmentInt32NativeLeaf(); |
| testPassStructNestedIntStructAlignmentInt64NativeLeaf(); |
| testPassStructNestedIrregularEvenBiggerx4NativeLeaf(); |
| testPassStruct8BytesInlineArrayIntx4NativeLeaf(); |
| testPassStructInlineArrayIrregularx4NativeLeaf(); |
| testPassStructInlineArray100BytesNativeLeaf(); |
| testPassStructStruct16BytesHomogeneousFloat2x5NativeLeaf(); |
| testPassStructStruct32BytesHomogeneousDouble2x5NativeLeaf(); |
| testPassStructStruct16BytesMixed3x10NativeLeaf(); |
| testPassUint8Struct32BytesInlineArrayMultiDimensionalINativeLeaf(); |
| testPassUint8Struct4BytesInlineArrayMultiDimensionalInNativeLeaf(); |
| testPassStruct3BytesPackedIntx10NativeLeaf(); |
| testPassStruct8BytesPackedIntx10NativeLeaf(); |
| testPassStruct9BytesPackedMixedx10DoubleInt32x2NativeLeaf(); |
| testPassStruct5BytesPackedMixedNativeLeaf(); |
| testPassStructNestedAlignmentStruct5BytesPackedMixedNativeLeaf(); |
| testPassStruct6BytesInlineArrayIntNativeLeaf(); |
| testPassStruct15BytesInlineArrayMixedNativeLeaf(); |
| testPassUnion4BytesMixedx10NativeLeaf(); |
| testPassUnion8BytesNestedFloatx10NativeLeaf(); |
| testPassUnion9BytesNestedIntx10NativeLeaf(); |
| testPassUnion16BytesNestedInlineArrayFloatx10NativeLeaf(); |
| testPassUnion16BytesNestedFloatx10NativeLeaf(); |
| testPassUint8Boolx9Struct10BytesHomogeneousBoolBoolNativeLeaf(); |
| testPassUint8Boolx9Struct10BytesInlineArrayBoolBoolNativeLeaf(); |
| testPassUint8Struct1ByteBoolNativeLeaf(); |
| testPassWCharStructInlineArrayIntUintPtrx2LongUnsignedNativeLeaf(); |
| testPassInt64x7Struct12BytesHomogeneousInt32NativeLeaf(); |
| testPassPointerStruct12BytesHomogeneousInt32NativeLeaf(); |
| testPassPointerStructInlineArrayVariableNativeLeaf(); |
| testPassPointerStructInlineArrayVariableAlignNativeLeaf(); |
| testPassPointerStructInlineArrayVariable2NativeLeaf(); |
| } |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| Struct1ByteInt, |
| ) |
| >(symbol: 'PassStruct1ByteIntx10', isLeaf: true) |
| external int passStruct1ByteIntx10NativeLeaf( |
| Struct1ByteInt a0, |
| Struct1ByteInt a1, |
| Struct1ByteInt a2, |
| Struct1ByteInt a3, |
| Struct1ByteInt a4, |
| Struct1ByteInt a5, |
| Struct1ByteInt a6, |
| Struct1ByteInt a7, |
| Struct1ByteInt a8, |
| Struct1ByteInt a9, |
| ); |
| |
| /// Smallest struct with data. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct1ByteIntx10NativeLeaf() { |
| final a0Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a1.a0 = 2; |
| a2.a0 = -3; |
| a3.a0 = 4; |
| a4.a0 = -5; |
| a5.a0 = 6; |
| a6.a0 = -7; |
| a7.a0 = 8; |
| a8.a0 = -9; |
| a9.a0 = 10; |
| |
| final result = passStruct1ByteIntx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(5, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| Struct3BytesHomogeneousUint8, |
| ) |
| >(symbol: 'PassStruct3BytesHomogeneousUint8x10', isLeaf: true) |
| external int passStruct3BytesHomogeneousUint8x10NativeLeaf( |
| Struct3BytesHomogeneousUint8 a0, |
| Struct3BytesHomogeneousUint8 a1, |
| Struct3BytesHomogeneousUint8 a2, |
| Struct3BytesHomogeneousUint8 a3, |
| Struct3BytesHomogeneousUint8 a4, |
| Struct3BytesHomogeneousUint8 a5, |
| Struct3BytesHomogeneousUint8 a6, |
| Struct3BytesHomogeneousUint8 a7, |
| Struct3BytesHomogeneousUint8 a8, |
| Struct3BytesHomogeneousUint8 a9, |
| ); |
| |
| /// Not a multiple of word size, not a power of two. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct3BytesHomogeneousUint8x10NativeLeaf() { |
| final a0Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct3BytesHomogeneousUint8>(); |
| final Struct3BytesHomogeneousUint8 a9 = a9Pointer.ref; |
| |
| a0.a0 = 1; |
| a0.a1 = 2; |
| a0.a2 = 3; |
| a1.a0 = 4; |
| a1.a1 = 5; |
| a1.a2 = 6; |
| a2.a0 = 7; |
| a2.a1 = 8; |
| a2.a2 = 9; |
| a3.a0 = 10; |
| a3.a1 = 11; |
| a3.a2 = 12; |
| a4.a0 = 13; |
| a4.a1 = 14; |
| a4.a2 = 15; |
| a5.a0 = 16; |
| a5.a1 = 17; |
| a5.a2 = 18; |
| a6.a0 = 19; |
| a6.a1 = 20; |
| a6.a2 = 21; |
| a7.a0 = 22; |
| a7.a1 = 23; |
| a7.a2 = 24; |
| a8.a0 = 25; |
| a8.a1 = 26; |
| a8.a2 = 27; |
| a9.a0 = 28; |
| a9.a1 = 29; |
| a9.a2 = 30; |
| |
| final result = passStruct3BytesHomogeneousUint8x10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(465, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| Struct3BytesInt2ByteAligned, |
| ) |
| >(symbol: 'PassStruct3BytesInt2ByteAlignedx10', isLeaf: true) |
| external int passStruct3BytesInt2ByteAlignedx10NativeLeaf( |
| Struct3BytesInt2ByteAligned a0, |
| Struct3BytesInt2ByteAligned a1, |
| Struct3BytesInt2ByteAligned a2, |
| Struct3BytesInt2ByteAligned a3, |
| Struct3BytesInt2ByteAligned a4, |
| Struct3BytesInt2ByteAligned a5, |
| Struct3BytesInt2ByteAligned a6, |
| Struct3BytesInt2ByteAligned a7, |
| Struct3BytesInt2ByteAligned a8, |
| Struct3BytesInt2ByteAligned a9, |
| ); |
| |
| /// Not a multiple of word size, not a power of two. |
| /// With alignment rules taken into account size is 4 bytes. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct3BytesInt2ByteAlignedx10NativeLeaf() { |
| final a0Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct3BytesInt2ByteAligned>(); |
| final Struct3BytesInt2ByteAligned a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a0.a1 = 2; |
| a1.a0 = -3; |
| a1.a1 = 4; |
| a2.a0 = -5; |
| a2.a1 = 6; |
| a3.a0 = -7; |
| a3.a1 = 8; |
| a4.a0 = -9; |
| a4.a1 = 10; |
| a5.a0 = -11; |
| a5.a1 = 12; |
| a6.a0 = -13; |
| a6.a1 = 14; |
| a7.a0 = -15; |
| a7.a1 = 16; |
| a8.a0 = -17; |
| a8.a1 = 18; |
| a9.a0 = -19; |
| a9.a1 = 20; |
| |
| final result = passStruct3BytesInt2ByteAlignedx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(10, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| Struct4BytesHomogeneousInt16, |
| ) |
| >(symbol: 'PassStruct4BytesHomogeneousInt16x10', isLeaf: true) |
| external int passStruct4BytesHomogeneousInt16x10NativeLeaf( |
| Struct4BytesHomogeneousInt16 a0, |
| Struct4BytesHomogeneousInt16 a1, |
| Struct4BytesHomogeneousInt16 a2, |
| Struct4BytesHomogeneousInt16 a3, |
| Struct4BytesHomogeneousInt16 a4, |
| Struct4BytesHomogeneousInt16 a5, |
| Struct4BytesHomogeneousInt16 a6, |
| Struct4BytesHomogeneousInt16 a7, |
| Struct4BytesHomogeneousInt16 a8, |
| Struct4BytesHomogeneousInt16 a9, |
| ); |
| |
| /// Exactly word size on 32-bit architectures. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct4BytesHomogeneousInt16x10NativeLeaf() { |
| final a0Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a0.a1 = 2; |
| a1.a0 = -3; |
| a1.a1 = 4; |
| a2.a0 = -5; |
| a2.a1 = 6; |
| a3.a0 = -7; |
| a3.a1 = 8; |
| a4.a0 = -9; |
| a4.a1 = 10; |
| a5.a0 = -11; |
| a5.a1 = 12; |
| a6.a0 = -13; |
| a6.a1 = 14; |
| a7.a0 = -15; |
| a7.a1 = 16; |
| a8.a0 = -17; |
| a8.a1 = 18; |
| a9.a0 = -19; |
| a9.a1 = 20; |
| |
| final result = passStruct4BytesHomogeneousInt16x10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(10, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| Struct7BytesHomogeneousUint8, |
| ) |
| >(symbol: 'PassStruct7BytesHomogeneousUint8x10', isLeaf: true) |
| external int passStruct7BytesHomogeneousUint8x10NativeLeaf( |
| Struct7BytesHomogeneousUint8 a0, |
| Struct7BytesHomogeneousUint8 a1, |
| Struct7BytesHomogeneousUint8 a2, |
| Struct7BytesHomogeneousUint8 a3, |
| Struct7BytesHomogeneousUint8 a4, |
| Struct7BytesHomogeneousUint8 a5, |
| Struct7BytesHomogeneousUint8 a6, |
| Struct7BytesHomogeneousUint8 a7, |
| Struct7BytesHomogeneousUint8 a8, |
| Struct7BytesHomogeneousUint8 a9, |
| ); |
| |
| /// Sub word size on 64 bit architectures. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct7BytesHomogeneousUint8x10NativeLeaf() { |
| final a0Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct7BytesHomogeneousUint8>(); |
| final Struct7BytesHomogeneousUint8 a9 = a9Pointer.ref; |
| |
| a0.a0 = 1; |
| a0.a1 = 2; |
| a0.a2 = 3; |
| a0.a3 = 4; |
| a0.a4 = 5; |
| a0.a5 = 6; |
| a0.a6 = 7; |
| a1.a0 = 8; |
| a1.a1 = 9; |
| a1.a2 = 10; |
| a1.a3 = 11; |
| a1.a4 = 12; |
| a1.a5 = 13; |
| a1.a6 = 14; |
| a2.a0 = 15; |
| a2.a1 = 16; |
| a2.a2 = 17; |
| a2.a3 = 18; |
| a2.a4 = 19; |
| a2.a5 = 20; |
| a2.a6 = 21; |
| a3.a0 = 22; |
| a3.a1 = 23; |
| a3.a2 = 24; |
| a3.a3 = 25; |
| a3.a4 = 26; |
| a3.a5 = 27; |
| a3.a6 = 28; |
| a4.a0 = 29; |
| a4.a1 = 30; |
| a4.a2 = 31; |
| a4.a3 = 32; |
| a4.a4 = 33; |
| a4.a5 = 34; |
| a4.a6 = 35; |
| a5.a0 = 36; |
| a5.a1 = 37; |
| a5.a2 = 38; |
| a5.a3 = 39; |
| a5.a4 = 40; |
| a5.a5 = 41; |
| a5.a6 = 42; |
| a6.a0 = 43; |
| a6.a1 = 44; |
| a6.a2 = 45; |
| a6.a3 = 46; |
| a6.a4 = 47; |
| a6.a5 = 48; |
| a6.a6 = 49; |
| a7.a0 = 50; |
| a7.a1 = 51; |
| a7.a2 = 52; |
| a7.a3 = 53; |
| a7.a4 = 54; |
| a7.a5 = 55; |
| a7.a6 = 56; |
| a8.a0 = 57; |
| a8.a1 = 58; |
| a8.a2 = 59; |
| a8.a3 = 60; |
| a8.a4 = 61; |
| a8.a5 = 62; |
| a8.a6 = 63; |
| a9.a0 = 64; |
| a9.a1 = 65; |
| a9.a2 = 66; |
| a9.a3 = 67; |
| a9.a4 = 68; |
| a9.a5 = 69; |
| a9.a6 = 70; |
| |
| final result = passStruct7BytesHomogeneousUint8x10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(2485, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| Struct7BytesInt4ByteAligned, |
| ) |
| >(symbol: 'PassStruct7BytesInt4ByteAlignedx10', isLeaf: true) |
| external int passStruct7BytesInt4ByteAlignedx10NativeLeaf( |
| Struct7BytesInt4ByteAligned a0, |
| Struct7BytesInt4ByteAligned a1, |
| Struct7BytesInt4ByteAligned a2, |
| Struct7BytesInt4ByteAligned a3, |
| Struct7BytesInt4ByteAligned a4, |
| Struct7BytesInt4ByteAligned a5, |
| Struct7BytesInt4ByteAligned a6, |
| Struct7BytesInt4ByteAligned a7, |
| Struct7BytesInt4ByteAligned a8, |
| Struct7BytesInt4ByteAligned a9, |
| ); |
| |
| /// Sub word size on 64 bit architectures. |
| /// With alignment rules taken into account size is 8 bytes. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct7BytesInt4ByteAlignedx10NativeLeaf() { |
| final a0Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct7BytesInt4ByteAligned>(); |
| final Struct7BytesInt4ByteAligned a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a0.a1 = 2; |
| a0.a2 = -3; |
| a1.a0 = 4; |
| a1.a1 = -5; |
| a1.a2 = 6; |
| a2.a0 = -7; |
| a2.a1 = 8; |
| a2.a2 = -9; |
| a3.a0 = 10; |
| a3.a1 = -11; |
| a3.a2 = 12; |
| a4.a0 = -13; |
| a4.a1 = 14; |
| a4.a2 = -15; |
| a5.a0 = 16; |
| a5.a1 = -17; |
| a5.a2 = 18; |
| a6.a0 = -19; |
| a6.a1 = 20; |
| a6.a2 = -21; |
| a7.a0 = 22; |
| a7.a1 = -23; |
| a7.a2 = 24; |
| a8.a0 = -25; |
| a8.a1 = 26; |
| a8.a2 = -27; |
| a9.a0 = 28; |
| a9.a1 = -29; |
| a9.a2 = 30; |
| |
| final result = passStruct7BytesInt4ByteAlignedx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(15, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| Struct8BytesInt, |
| ) |
| >(symbol: 'PassStruct8BytesIntx10', isLeaf: true) |
| external int passStruct8BytesIntx10NativeLeaf( |
| Struct8BytesInt a0, |
| Struct8BytesInt a1, |
| Struct8BytesInt a2, |
| Struct8BytesInt a3, |
| Struct8BytesInt a4, |
| Struct8BytesInt a5, |
| Struct8BytesInt a6, |
| Struct8BytesInt a7, |
| Struct8BytesInt a8, |
| Struct8BytesInt a9, |
| ); |
| |
| /// Exactly word size struct on 64bit architectures. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct8BytesIntx10NativeLeaf() { |
| final a0Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a0.a1 = 2; |
| a0.a2 = -3; |
| a1.a0 = 4; |
| a1.a1 = -5; |
| a1.a2 = 6; |
| a2.a0 = -7; |
| a2.a1 = 8; |
| a2.a2 = -9; |
| a3.a0 = 10; |
| a3.a1 = -11; |
| a3.a2 = 12; |
| a4.a0 = -13; |
| a4.a1 = 14; |
| a4.a2 = -15; |
| a5.a0 = 16; |
| a5.a1 = -17; |
| a5.a2 = 18; |
| a6.a0 = -19; |
| a6.a1 = 20; |
| a6.a2 = -21; |
| a7.a0 = 22; |
| a7.a1 = -23; |
| a7.a2 = 24; |
| a8.a0 = -25; |
| a8.a1 = 26; |
| a8.a2 = -27; |
| a9.a0 = 28; |
| a9.a1 = -29; |
| a9.a2 = 30; |
| |
| final result = passStruct8BytesIntx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(15, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Float Function( |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| Struct8BytesHomogeneousFloat, |
| ) |
| >(symbol: 'PassStruct8BytesHomogeneousFloatx10', isLeaf: true) |
| external double passStruct8BytesHomogeneousFloatx10NativeLeaf( |
| Struct8BytesHomogeneousFloat a0, |
| Struct8BytesHomogeneousFloat a1, |
| Struct8BytesHomogeneousFloat a2, |
| Struct8BytesHomogeneousFloat a3, |
| Struct8BytesHomogeneousFloat a4, |
| Struct8BytesHomogeneousFloat a5, |
| Struct8BytesHomogeneousFloat a6, |
| Struct8BytesHomogeneousFloat a7, |
| Struct8BytesHomogeneousFloat a8, |
| Struct8BytesHomogeneousFloat a9, |
| ); |
| |
| /// Arguments passed in FP registers as long as they fit. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct8BytesHomogeneousFloatx10NativeLeaf() { |
| final a0Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a9 = a9Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a1.a0 = -3.0; |
| a1.a1 = 4.0; |
| a2.a0 = -5.0; |
| a2.a1 = 6.0; |
| a3.a0 = -7.0; |
| a3.a1 = 8.0; |
| a4.a0 = -9.0; |
| a4.a1 = 10.0; |
| a5.a0 = -11.0; |
| a5.a1 = 12.0; |
| a6.a0 = -13.0; |
| a6.a1 = 14.0; |
| a7.a0 = -15.0; |
| a7.a1 = 16.0; |
| a8.a0 = -17.0; |
| a8.a1 = 18.0; |
| a9.a0 = -19.0; |
| a9.a1 = 20.0; |
| |
| final result = passStruct8BytesHomogeneousFloatx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(10.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Float Function( |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| Struct8BytesMixed, |
| ) |
| >(symbol: 'PassStruct8BytesMixedx10', isLeaf: true) |
| external double passStruct8BytesMixedx10NativeLeaf( |
| Struct8BytesMixed a0, |
| Struct8BytesMixed a1, |
| Struct8BytesMixed a2, |
| Struct8BytesMixed a3, |
| Struct8BytesMixed a4, |
| Struct8BytesMixed a5, |
| Struct8BytesMixed a6, |
| Struct8BytesMixed a7, |
| Struct8BytesMixed a8, |
| Struct8BytesMixed a9, |
| ); |
| |
| /// On x64, arguments go in int registers because it is not only float. |
| /// 10 struct arguments will exhaust available registers. |
| void testPassStruct8BytesMixedx10NativeLeaf() { |
| final a0Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct8BytesMixed>(); |
| final Struct8BytesMixed a9 = a9Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2; |
| a0.a2 = -3; |
| a1.a0 = 4.0; |
| a1.a1 = -5; |
| a1.a2 = 6; |
| a2.a0 = -7.0; |
| a2.a1 = 8; |
| a2.a2 = -9; |
| a3.a0 = 10.0; |
| a3.a1 = -11; |
| a3.a2 = 12; |
| a4.a0 = -13.0; |
| a4.a1 = 14; |
| a4.a2 = -15; |
| a5.a0 = 16.0; |
| a5.a1 = -17; |
| a5.a2 = 18; |
| a6.a0 = -19.0; |
| a6.a1 = 20; |
| a6.a2 = -21; |
| a7.a0 = 22.0; |
| a7.a1 = -23; |
| a7.a2 = 24; |
| a8.a0 = -25.0; |
| a8.a1 = 26; |
| a8.a2 = -27; |
| a9.a0 = 28.0; |
| a9.a1 = -29; |
| a9.a2 = 30; |
| |
| final result = passStruct8BytesMixedx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(15.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| Struct9BytesHomogeneousUint8, |
| ) |
| >(symbol: 'PassStruct9BytesHomogeneousUint8x10', isLeaf: true) |
| external int passStruct9BytesHomogeneousUint8x10NativeLeaf( |
| Struct9BytesHomogeneousUint8 a0, |
| Struct9BytesHomogeneousUint8 a1, |
| Struct9BytesHomogeneousUint8 a2, |
| Struct9BytesHomogeneousUint8 a3, |
| Struct9BytesHomogeneousUint8 a4, |
| Struct9BytesHomogeneousUint8 a5, |
| Struct9BytesHomogeneousUint8 a6, |
| Struct9BytesHomogeneousUint8 a7, |
| Struct9BytesHomogeneousUint8 a8, |
| Struct9BytesHomogeneousUint8 a9, |
| ); |
| |
| /// Argument is a single byte over a multiple of word size. |
| /// 10 struct arguments will exhaust available registers. |
| /// Struct only has 1-byte aligned fields to test struct alignment itself. |
| /// Tests upper bytes in the integer registers that are partly filled. |
| /// Tests stack alignment of non word size stack arguments. |
| void testPassStruct9BytesHomogeneousUint8x10NativeLeaf() { |
| final a0Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct9BytesHomogeneousUint8>(); |
| final Struct9BytesHomogeneousUint8 a9 = a9Pointer.ref; |
| |
| a0.a0 = 1; |
| a0.a1 = 2; |
| a0.a2 = 3; |
| a0.a3 = 4; |
| a0.a4 = 5; |
| a0.a5 = 6; |
| a0.a6 = 7; |
| a0.a7 = 8; |
| a0.a8 = 9; |
| a1.a0 = 10; |
| a1.a1 = 11; |
| a1.a2 = 12; |
| a1.a3 = 13; |
| a1.a4 = 14; |
| a1.a5 = 15; |
| a1.a6 = 16; |
| a1.a7 = 17; |
| a1.a8 = 18; |
| a2.a0 = 19; |
| a2.a1 = 20; |
| a2.a2 = 21; |
| a2.a3 = 22; |
| a2.a4 = 23; |
| a2.a5 = 24; |
| a2.a6 = 25; |
| a2.a7 = 26; |
| a2.a8 = 27; |
| a3.a0 = 28; |
| a3.a1 = 29; |
| a3.a2 = 30; |
| a3.a3 = 31; |
| a3.a4 = 32; |
| a3.a5 = 33; |
| a3.a6 = 34; |
| a3.a7 = 35; |
| a3.a8 = 36; |
| a4.a0 = 37; |
| a4.a1 = 38; |
| a4.a2 = 39; |
| a4.a3 = 40; |
| a4.a4 = 41; |
| a4.a5 = 42; |
| a4.a6 = 43; |
| a4.a7 = 44; |
| a4.a8 = 45; |
| a5.a0 = 46; |
| a5.a1 = 47; |
| a5.a2 = 48; |
| a5.a3 = 49; |
| a5.a4 = 50; |
| a5.a5 = 51; |
| a5.a6 = 52; |
| a5.a7 = 53; |
| a5.a8 = 54; |
| a6.a0 = 55; |
| a6.a1 = 56; |
| a6.a2 = 57; |
| a6.a3 = 58; |
| a6.a4 = 59; |
| a6.a5 = 60; |
| a6.a6 = 61; |
| a6.a7 = 62; |
| a6.a8 = 63; |
| a7.a0 = 64; |
| a7.a1 = 65; |
| a7.a2 = 66; |
| a7.a3 = 67; |
| a7.a4 = 68; |
| a7.a5 = 69; |
| a7.a6 = 70; |
| a7.a7 = 71; |
| a7.a8 = 72; |
| a8.a0 = 73; |
| a8.a1 = 74; |
| a8.a2 = 75; |
| a8.a3 = 76; |
| a8.a4 = 77; |
| a8.a5 = 78; |
| a8.a6 = 79; |
| a8.a7 = 80; |
| a8.a8 = 81; |
| a9.a0 = 82; |
| a9.a1 = 83; |
| a9.a2 = 84; |
| a9.a3 = 85; |
| a9.a4 = 86; |
| a9.a5 = 87; |
| a9.a6 = 88; |
| a9.a7 = 89; |
| a9.a8 = 90; |
| |
| final result = passStruct9BytesHomogeneousUint8x10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(4095, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| Struct9BytesInt4Or8ByteAligned, |
| ) |
| >(symbol: 'PassStruct9BytesInt4Or8ByteAlignedx10', isLeaf: true) |
| external int passStruct9BytesInt4Or8ByteAlignedx10NativeLeaf( |
| Struct9BytesInt4Or8ByteAligned a0, |
| Struct9BytesInt4Or8ByteAligned a1, |
| Struct9BytesInt4Or8ByteAligned a2, |
| Struct9BytesInt4Or8ByteAligned a3, |
| Struct9BytesInt4Or8ByteAligned a4, |
| Struct9BytesInt4Or8ByteAligned a5, |
| Struct9BytesInt4Or8ByteAligned a6, |
| Struct9BytesInt4Or8ByteAligned a7, |
| Struct9BytesInt4Or8ByteAligned a8, |
| Struct9BytesInt4Or8ByteAligned a9, |
| ); |
| |
| /// Argument is a single byte over a multiple of word size. |
| /// With alignment rules taken into account size is 12 or 16 bytes. |
| /// 10 struct arguments will exhaust available registers. |
| /// |
| void testPassStruct9BytesInt4Or8ByteAlignedx10NativeLeaf() { |
| final a0Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct9BytesInt4Or8ByteAligned>(); |
| final Struct9BytesInt4Or8ByteAligned a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a0.a1 = 2; |
| a1.a0 = -3; |
| a1.a1 = 4; |
| a2.a0 = -5; |
| a2.a1 = 6; |
| a3.a0 = -7; |
| a3.a1 = 8; |
| a4.a0 = -9; |
| a4.a1 = 10; |
| a5.a0 = -11; |
| a5.a1 = 12; |
| a6.a0 = -13; |
| a6.a1 = 14; |
| a7.a0 = -15; |
| a7.a1 = 16; |
| a8.a0 = -17; |
| a8.a1 = 18; |
| a9.a0 = -19; |
| a9.a1 = 20; |
| |
| final result = passStruct9BytesInt4Or8ByteAlignedx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(10, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Float Function( |
| Struct12BytesHomogeneousFloat, |
| Struct12BytesHomogeneousFloat, |
| Struct12BytesHomogeneousFloat, |
| Struct12BytesHomogeneousFloat, |
| Struct12BytesHomogeneousFloat, |
| Struct12BytesHomogeneousFloat, |
| ) |
| >(symbol: 'PassStruct12BytesHomogeneousFloatx6', isLeaf: true) |
| external double passStruct12BytesHomogeneousFloatx6NativeLeaf( |
| Struct12BytesHomogeneousFloat a0, |
| Struct12BytesHomogeneousFloat a1, |
| Struct12BytesHomogeneousFloat a2, |
| Struct12BytesHomogeneousFloat a3, |
| Struct12BytesHomogeneousFloat a4, |
| Struct12BytesHomogeneousFloat a5, |
| ); |
| |
| /// Arguments in FPU registers on arm hardfp and arm64. |
| /// Struct arguments will exhaust available registers, and leave some empty. |
| /// The last argument is to test whether arguments are backfilled. |
| void testPassStruct12BytesHomogeneousFloatx6NativeLeaf() { |
| final a0Pointer = calloc<Struct12BytesHomogeneousFloat>(); |
| final Struct12BytesHomogeneousFloat a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct12BytesHomogeneousFloat>(); |
| final Struct12BytesHomogeneousFloat a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct12BytesHomogeneousFloat>(); |
| final Struct12BytesHomogeneousFloat a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct12BytesHomogeneousFloat>(); |
| final Struct12BytesHomogeneousFloat a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct12BytesHomogeneousFloat>(); |
| final Struct12BytesHomogeneousFloat a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct12BytesHomogeneousFloat>(); |
| final Struct12BytesHomogeneousFloat a5 = a5Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a0.a2 = -3.0; |
| a1.a0 = 4.0; |
| a1.a1 = -5.0; |
| a1.a2 = 6.0; |
| a2.a0 = -7.0; |
| a2.a1 = 8.0; |
| a2.a2 = -9.0; |
| a3.a0 = 10.0; |
| a3.a1 = -11.0; |
| a3.a2 = 12.0; |
| a4.a0 = -13.0; |
| a4.a1 = 14.0; |
| a4.a2 = -15.0; |
| a5.a0 = 16.0; |
| a5.a1 = -17.0; |
| a5.a2 = 18.0; |
| |
| final result = passStruct12BytesHomogeneousFloatx6NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(9.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| } |
| |
| @Native< |
| Float Function( |
| Struct16BytesHomogeneousFloat, |
| Struct16BytesHomogeneousFloat, |
| Struct16BytesHomogeneousFloat, |
| Struct16BytesHomogeneousFloat, |
| Struct16BytesHomogeneousFloat, |
| ) |
| >(symbol: 'PassStruct16BytesHomogeneousFloatx5', isLeaf: true) |
| external double passStruct16BytesHomogeneousFloatx5NativeLeaf( |
| Struct16BytesHomogeneousFloat a0, |
| Struct16BytesHomogeneousFloat a1, |
| Struct16BytesHomogeneousFloat a2, |
| Struct16BytesHomogeneousFloat a3, |
| Struct16BytesHomogeneousFloat a4, |
| ); |
| |
| /// On Linux x64 argument is transferred on stack because it is over 16 bytes. |
| /// Arguments in FPU registers on arm hardfp and arm64. |
| /// 5 struct arguments will exhaust available registers. |
| void testPassStruct16BytesHomogeneousFloatx5NativeLeaf() { |
| final a0Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a4 = a4Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a0.a2 = -3.0; |
| a0.a3 = 4.0; |
| a1.a0 = -5.0; |
| a1.a1 = 6.0; |
| a1.a2 = -7.0; |
| a1.a3 = 8.0; |
| a2.a0 = -9.0; |
| a2.a1 = 10.0; |
| a2.a2 = -11.0; |
| a2.a3 = 12.0; |
| a3.a0 = -13.0; |
| a3.a1 = 14.0; |
| a3.a2 = -15.0; |
| a3.a3 = 16.0; |
| a4.a0 = -17.0; |
| a4.a1 = 18.0; |
| a4.a2 = -19.0; |
| a4.a3 = 20.0; |
| |
| final result = passStruct16BytesHomogeneousFloatx5NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(10.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| ) |
| >(symbol: 'PassStruct16BytesMixedx10', isLeaf: true) |
| external double passStruct16BytesMixedx10NativeLeaf( |
| Struct16BytesMixed a0, |
| Struct16BytesMixed a1, |
| Struct16BytesMixed a2, |
| Struct16BytesMixed a3, |
| Struct16BytesMixed a4, |
| Struct16BytesMixed a5, |
| Struct16BytesMixed a6, |
| Struct16BytesMixed a7, |
| Struct16BytesMixed a8, |
| Struct16BytesMixed a9, |
| ); |
| |
| /// On x64, arguments are split over FP and int registers. |
| /// On x64, it will exhaust the integer registers with the 6th argument. |
| /// The rest goes on the stack. |
| /// On arm, arguments are 8 byte aligned. |
| void testPassStruct16BytesMixedx10NativeLeaf() { |
| final a0Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a9 = a9Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2; |
| a1.a0 = -3.0; |
| a1.a1 = 4; |
| a2.a0 = -5.0; |
| a2.a1 = 6; |
| a3.a0 = -7.0; |
| a3.a1 = 8; |
| a4.a0 = -9.0; |
| a4.a1 = 10; |
| a5.a0 = -11.0; |
| a5.a1 = 12; |
| a6.a0 = -13.0; |
| a6.a1 = 14; |
| a7.a0 = -15.0; |
| a7.a1 = 16; |
| a8.a0 = -17.0; |
| a8.a1 = 18; |
| a9.a0 = -19.0; |
| a9.a1 = 20; |
| |
| final result = passStruct16BytesMixedx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(10.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Float Function( |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| Struct16BytesMixed2, |
| ) |
| >(symbol: 'PassStruct16BytesMixed2x10', isLeaf: true) |
| external double passStruct16BytesMixed2x10NativeLeaf( |
| Struct16BytesMixed2 a0, |
| Struct16BytesMixed2 a1, |
| Struct16BytesMixed2 a2, |
| Struct16BytesMixed2 a3, |
| Struct16BytesMixed2 a4, |
| Struct16BytesMixed2 a5, |
| Struct16BytesMixed2 a6, |
| Struct16BytesMixed2 a7, |
| Struct16BytesMixed2 a8, |
| Struct16BytesMixed2 a9, |
| ); |
| |
| /// On x64, arguments are split over FP and int registers. |
| /// On x64, it will exhaust the integer registers with the 6th argument. |
| /// The rest goes on the stack. |
| /// On arm, arguments are 4 byte aligned. |
| void testPassStruct16BytesMixed2x10NativeLeaf() { |
| final a0Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct16BytesMixed2>(); |
| final Struct16BytesMixed2 a9 = a9Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a0.a2 = -3.0; |
| a0.a3 = 4; |
| a1.a0 = -5.0; |
| a1.a1 = 6.0; |
| a1.a2 = -7.0; |
| a1.a3 = 8; |
| a2.a0 = -9.0; |
| a2.a1 = 10.0; |
| a2.a2 = -11.0; |
| a2.a3 = 12; |
| a3.a0 = -13.0; |
| a3.a1 = 14.0; |
| a3.a2 = -15.0; |
| a3.a3 = 16; |
| a4.a0 = -17.0; |
| a4.a1 = 18.0; |
| a4.a2 = -19.0; |
| a4.a3 = 20; |
| a5.a0 = -21.0; |
| a5.a1 = 22.0; |
| a5.a2 = -23.0; |
| a5.a3 = 24; |
| a6.a0 = -25.0; |
| a6.a1 = 26.0; |
| a6.a2 = -27.0; |
| a6.a3 = 28; |
| a7.a0 = -29.0; |
| a7.a1 = 30.0; |
| a7.a2 = -31.0; |
| a7.a3 = 32; |
| a8.a0 = -33.0; |
| a8.a1 = 34.0; |
| a8.a2 = -35.0; |
| a8.a3 = 36; |
| a9.a0 = -37.0; |
| a9.a1 = 38.0; |
| a9.a2 = -39.0; |
| a9.a3 = 40; |
| |
| final result = passStruct16BytesMixed2x10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(20.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| Struct17BytesInt, |
| ) |
| >(symbol: 'PassStruct17BytesIntx10', isLeaf: true) |
| external int passStruct17BytesIntx10NativeLeaf( |
| Struct17BytesInt a0, |
| Struct17BytesInt a1, |
| Struct17BytesInt a2, |
| Struct17BytesInt a3, |
| Struct17BytesInt a4, |
| Struct17BytesInt a5, |
| Struct17BytesInt a6, |
| Struct17BytesInt a7, |
| Struct17BytesInt a8, |
| Struct17BytesInt a9, |
| ); |
| |
| /// Arguments are passed as pointer to copy on arm64. |
| /// Tests that the memory allocated for copies are rounded up to word size. |
| void testPassStruct17BytesIntx10NativeLeaf() { |
| final a0Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct17BytesInt>(); |
| final Struct17BytesInt a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a0.a1 = 2; |
| a0.a2 = -3; |
| a1.a0 = 4; |
| a1.a1 = -5; |
| a1.a2 = 6; |
| a2.a0 = -7; |
| a2.a1 = 8; |
| a2.a2 = -9; |
| a3.a0 = 10; |
| a3.a1 = -11; |
| a3.a2 = 12; |
| a4.a0 = -13; |
| a4.a1 = 14; |
| a4.a2 = -15; |
| a5.a0 = 16; |
| a5.a1 = -17; |
| a5.a2 = 18; |
| a6.a0 = -19; |
| a6.a1 = 20; |
| a6.a2 = -21; |
| a7.a0 = 22; |
| a7.a1 = -23; |
| a7.a2 = 24; |
| a8.a0 = -25; |
| a8.a1 = 26; |
| a8.a2 = -27; |
| a9.a0 = 28; |
| a9.a1 = -29; |
| a9.a2 = 30; |
| |
| final result = passStruct17BytesIntx10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(15, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int64 Function( |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| Struct19BytesHomogeneousUint8, |
| ) |
| >(symbol: 'PassStruct19BytesHomogeneousUint8x10', isLeaf: true) |
| external int passStruct19BytesHomogeneousUint8x10NativeLeaf( |
| Struct19BytesHomogeneousUint8 a0, |
| Struct19BytesHomogeneousUint8 a1, |
| Struct19BytesHomogeneousUint8 a2, |
| Struct19BytesHomogeneousUint8 a3, |
| Struct19BytesHomogeneousUint8 a4, |
| Struct19BytesHomogeneousUint8 a5, |
| Struct19BytesHomogeneousUint8 a6, |
| Struct19BytesHomogeneousUint8 a7, |
| Struct19BytesHomogeneousUint8 a8, |
| Struct19BytesHomogeneousUint8 a9, |
| ); |
| |
| /// The minimum alignment of this struct is only 1 byte based on its fields. |
| /// Test that the memory backing these structs is extended to the right size. |
| /// |
| void testPassStruct19BytesHomogeneousUint8x10NativeLeaf() { |
| final a0Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct19BytesHomogeneousUint8>(); |
| final Struct19BytesHomogeneousUint8 a9 = a9Pointer.ref; |
| |
| a0.a0 = 1; |
| a0.a1 = 2; |
| a0.a2 = 3; |
| a0.a3 = 4; |
| a0.a4 = 5; |
| a0.a5 = 6; |
| a0.a6 = 7; |
| a0.a7 = 8; |
| a0.a8 = 9; |
| a0.a9 = 10; |
| a0.a10 = 11; |
| a0.a11 = 12; |
| a0.a12 = 13; |
| a0.a13 = 14; |
| a0.a14 = 15; |
| a0.a15 = 16; |
| a0.a16 = 17; |
| a0.a17 = 18; |
| a0.a18 = 19; |
| a1.a0 = 20; |
| a1.a1 = 21; |
| a1.a2 = 22; |
| a1.a3 = 23; |
| a1.a4 = 24; |
| a1.a5 = 25; |
| a1.a6 = 26; |
| a1.a7 = 27; |
| a1.a8 = 28; |
| a1.a9 = 29; |
| a1.a10 = 30; |
| a1.a11 = 31; |
| a1.a12 = 32; |
| a1.a13 = 33; |
| a1.a14 = 34; |
| a1.a15 = 35; |
| a1.a16 = 36; |
| a1.a17 = 37; |
| a1.a18 = 38; |
| a2.a0 = 39; |
| a2.a1 = 40; |
| a2.a2 = 41; |
| a2.a3 = 42; |
| a2.a4 = 43; |
| a2.a5 = 44; |
| a2.a6 = 45; |
| a2.a7 = 46; |
| a2.a8 = 47; |
| a2.a9 = 48; |
| a2.a10 = 49; |
| a2.a11 = 50; |
| a2.a12 = 51; |
| a2.a13 = 52; |
| a2.a14 = 53; |
| a2.a15 = 54; |
| a2.a16 = 55; |
| a2.a17 = 56; |
| a2.a18 = 57; |
| a3.a0 = 58; |
| a3.a1 = 59; |
| a3.a2 = 60; |
| a3.a3 = 61; |
| a3.a4 = 62; |
| a3.a5 = 63; |
| a3.a6 = 64; |
| a3.a7 = 65; |
| a3.a8 = 66; |
| a3.a9 = 67; |
| a3.a10 = 68; |
| a3.a11 = 69; |
| a3.a12 = 70; |
| a3.a13 = 71; |
| a3.a14 = 72; |
| a3.a15 = 73; |
| a3.a16 = 74; |
| a3.a17 = 75; |
| a3.a18 = 76; |
| a4.a0 = 77; |
| a4.a1 = 78; |
| a4.a2 = 79; |
| a4.a3 = 80; |
| a4.a4 = 81; |
| a4.a5 = 82; |
| a4.a6 = 83; |
| a4.a7 = 84; |
| a4.a8 = 85; |
| a4.a9 = 86; |
| a4.a10 = 87; |
| a4.a11 = 88; |
| a4.a12 = 89; |
| a4.a13 = 90; |
| a4.a14 = 91; |
| a4.a15 = 92; |
| a4.a16 = 93; |
| a4.a17 = 94; |
| a4.a18 = 95; |
| a5.a0 = 96; |
| a5.a1 = 97; |
| a5.a2 = 98; |
| a5.a3 = 99; |
| a5.a4 = 100; |
| a5.a5 = 101; |
| a5.a6 = 102; |
| a5.a7 = 103; |
| a5.a8 = 104; |
| a5.a9 = 105; |
| a5.a10 = 106; |
| a5.a11 = 107; |
| a5.a12 = 108; |
| a5.a13 = 109; |
| a5.a14 = 110; |
| a5.a15 = 111; |
| a5.a16 = 112; |
| a5.a17 = 113; |
| a5.a18 = 114; |
| a6.a0 = 115; |
| a6.a1 = 116; |
| a6.a2 = 117; |
| a6.a3 = 118; |
| a6.a4 = 119; |
| a6.a5 = 120; |
| a6.a6 = 121; |
| a6.a7 = 122; |
| a6.a8 = 123; |
| a6.a9 = 124; |
| a6.a10 = 125; |
| a6.a11 = 126; |
| a6.a12 = 127; |
| a6.a13 = 128; |
| a6.a14 = 129; |
| a6.a15 = 130; |
| a6.a16 = 131; |
| a6.a17 = 132; |
| a6.a18 = 133; |
| a7.a0 = 134; |
| a7.a1 = 135; |
| a7.a2 = 136; |
| a7.a3 = 137; |
| a7.a4 = 138; |
| a7.a5 = 139; |
| a7.a6 = 140; |
| a7.a7 = 141; |
| a7.a8 = 142; |
| a7.a9 = 143; |
| a7.a10 = 144; |
| a7.a11 = 145; |
| a7.a12 = 146; |
| a7.a13 = 147; |
| a7.a14 = 148; |
| a7.a15 = 149; |
| a7.a16 = 150; |
| a7.a17 = 151; |
| a7.a18 = 152; |
| a8.a0 = 153; |
| a8.a1 = 154; |
| a8.a2 = 155; |
| a8.a3 = 156; |
| a8.a4 = 157; |
| a8.a5 = 158; |
| a8.a6 = 159; |
| a8.a7 = 160; |
| a8.a8 = 161; |
| a8.a9 = 162; |
| a8.a10 = 163; |
| a8.a11 = 164; |
| a8.a12 = 165; |
| a8.a13 = 166; |
| a8.a14 = 167; |
| a8.a15 = 168; |
| a8.a16 = 169; |
| a8.a17 = 170; |
| a8.a18 = 171; |
| a9.a0 = 172; |
| a9.a1 = 173; |
| a9.a2 = 174; |
| a9.a3 = 175; |
| a9.a4 = 176; |
| a9.a5 = 177; |
| a9.a6 = 178; |
| a9.a7 = 179; |
| a9.a8 = 180; |
| a9.a9 = 181; |
| a9.a10 = 182; |
| a9.a11 = 183; |
| a9.a12 = 184; |
| a9.a13 = 185; |
| a9.a14 = 186; |
| a9.a15 = 187; |
| a9.a16 = 188; |
| a9.a17 = 189; |
| a9.a18 = 190; |
| |
| final result = passStruct19BytesHomogeneousUint8x10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(18145, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Int32 Function( |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| Struct20BytesHomogeneousInt32, |
| ) |
| >(symbol: 'PassStruct20BytesHomogeneousInt32x10', isLeaf: true) |
| external int passStruct20BytesHomogeneousInt32x10NativeLeaf( |
| Struct20BytesHomogeneousInt32 a0, |
| Struct20BytesHomogeneousInt32 a1, |
| Struct20BytesHomogeneousInt32 a2, |
| Struct20BytesHomogeneousInt32 a3, |
| Struct20BytesHomogeneousInt32 a4, |
| Struct20BytesHomogeneousInt32 a5, |
| Struct20BytesHomogeneousInt32 a6, |
| Struct20BytesHomogeneousInt32 a7, |
| Struct20BytesHomogeneousInt32 a8, |
| Struct20BytesHomogeneousInt32 a9, |
| ); |
| |
| /// Argument too big to go into integer registers on arm64. |
| /// The arguments are passed as pointers to copies. |
| /// The amount of arguments exhausts the number of integer registers, such that |
| /// pointers to copies are also passed on the stack. |
| void testPassStruct20BytesHomogeneousInt32x10NativeLeaf() { |
| final a0Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct20BytesHomogeneousInt32>(); |
| final Struct20BytesHomogeneousInt32 a9 = a9Pointer.ref; |
| |
| a0.a0 = -1; |
| a0.a1 = 2; |
| a0.a2 = -3; |
| a0.a3 = 4; |
| a0.a4 = -5; |
| a1.a0 = 6; |
| a1.a1 = -7; |
| a1.a2 = 8; |
| a1.a3 = -9; |
| a1.a4 = 10; |
| a2.a0 = -11; |
| a2.a1 = 12; |
| a2.a2 = -13; |
| a2.a3 = 14; |
| a2.a4 = -15; |
| a3.a0 = 16; |
| a3.a1 = -17; |
| a3.a2 = 18; |
| a3.a3 = -19; |
| a3.a4 = 20; |
| a4.a0 = -21; |
| a4.a1 = 22; |
| a4.a2 = -23; |
| a4.a3 = 24; |
| a4.a4 = -25; |
| a5.a0 = 26; |
| a5.a1 = -27; |
| a5.a2 = 28; |
| a5.a3 = -29; |
| a5.a4 = 30; |
| a6.a0 = -31; |
| a6.a1 = 32; |
| a6.a2 = -33; |
| a6.a3 = 34; |
| a6.a4 = -35; |
| a7.a0 = 36; |
| a7.a1 = -37; |
| a7.a2 = 38; |
| a7.a3 = -39; |
| a7.a4 = 40; |
| a8.a0 = -41; |
| a8.a1 = 42; |
| a8.a2 = -43; |
| a8.a3 = 44; |
| a8.a4 = -45; |
| a9.a0 = 46; |
| a9.a1 = -47; |
| a9.a2 = 48; |
| a9.a3 = -49; |
| a9.a4 = 50; |
| |
| final result = passStruct20BytesHomogeneousInt32x10NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.equals(25, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native<Float Function(Struct20BytesHomogeneousFloat)>( |
| symbol: 'PassStruct20BytesHomogeneousFloat', |
| isLeaf: true, |
| ) |
| external double passStruct20BytesHomogeneousFloatNativeLeaf( |
| Struct20BytesHomogeneousFloat a0, |
| ); |
| |
| /// Argument too big to go into FPU registers in hardfp and arm64. |
| void testPassStruct20BytesHomogeneousFloatNativeLeaf() { |
| final a0Pointer = calloc<Struct20BytesHomogeneousFloat>(); |
| final Struct20BytesHomogeneousFloat a0 = a0Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a0.a2 = -3.0; |
| a0.a3 = 4.0; |
| a0.a4 = -5.0; |
| |
| final result = passStruct20BytesHomogeneousFloatNativeLeaf(a0); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-3.0, result); |
| |
| calloc.free(a0Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Struct32BytesHomogeneousDouble, |
| Struct32BytesHomogeneousDouble, |
| Struct32BytesHomogeneousDouble, |
| Struct32BytesHomogeneousDouble, |
| Struct32BytesHomogeneousDouble, |
| ) |
| >(symbol: 'PassStruct32BytesHomogeneousDoublex5', isLeaf: true) |
| external double passStruct32BytesHomogeneousDoublex5NativeLeaf( |
| Struct32BytesHomogeneousDouble a0, |
| Struct32BytesHomogeneousDouble a1, |
| Struct32BytesHomogeneousDouble a2, |
| Struct32BytesHomogeneousDouble a3, |
| Struct32BytesHomogeneousDouble a4, |
| ); |
| |
| /// Arguments in FPU registers on arm64. |
| /// 5 struct arguments will exhaust available registers. |
| void testPassStruct32BytesHomogeneousDoublex5NativeLeaf() { |
| final a0Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a2 = a2Pointer.ref; |
| final a3Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a3 = a3Pointer.ref; |
| final a4Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a4 = a4Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a0.a2 = -3.0; |
| a0.a3 = 4.0; |
| a1.a0 = -5.0; |
| a1.a1 = 6.0; |
| a1.a2 = -7.0; |
| a1.a3 = 8.0; |
| a2.a0 = -9.0; |
| a2.a1 = 10.0; |
| a2.a2 = -11.0; |
| a2.a3 = 12.0; |
| a3.a0 = -13.0; |
| a3.a1 = 14.0; |
| a3.a2 = -15.0; |
| a3.a3 = 16.0; |
| a4.a0 = -17.0; |
| a4.a1 = 18.0; |
| a4.a2 = -19.0; |
| a4.a3 = 20.0; |
| |
| final result = passStruct32BytesHomogeneousDoublex5NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(10.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a4Pointer); |
| } |
| |
| @Native<Double Function(Struct40BytesHomogeneousDouble)>( |
| symbol: 'PassStruct40BytesHomogeneousDouble', |
| isLeaf: true, |
| ) |
| external double passStruct40BytesHomogeneousDoubleNativeLeaf( |
| Struct40BytesHomogeneousDouble a0, |
| ); |
| |
| /// Argument too big to go into FPU registers in arm64. |
| void testPassStruct40BytesHomogeneousDoubleNativeLeaf() { |
| final a0Pointer = calloc<Struct40BytesHomogeneousDouble>(); |
| final Struct40BytesHomogeneousDouble a0 = a0Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a0.a2 = -3.0; |
| a0.a3 = 4.0; |
| a0.a4 = -5.0; |
| |
| final result = passStruct40BytesHomogeneousDoubleNativeLeaf(a0); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-3.0, result); |
| |
| calloc.free(a0Pointer); |
| } |
| |
| @Native<Uint64 Function(Struct1024BytesHomogeneousUint64)>( |
| symbol: 'PassStruct1024BytesHomogeneousUint64', |
| isLeaf: true, |
| ) |
| external int passStruct1024BytesHomogeneousUint64NativeLeaf( |
| Struct1024BytesHomogeneousUint64 a0, |
| ); |
| |
| /// Test 1kb struct. |
| void testPassStruct1024BytesHomogeneousUint64NativeLeaf() { |
| final a0Pointer = calloc<Struct1024BytesHomogeneousUint64>(); |
| final Struct1024BytesHomogeneousUint64 a0 = a0Pointer.ref; |
| |
| a0.a0 = 1; |
| a0.a1 = 2; |
| a0.a2 = 3; |
| a0.a3 = 4; |
| a0.a4 = 5; |
| a0.a5 = 6; |
| a0.a6 = 7; |
| a0.a7 = 8; |
| a0.a8 = 9; |
| a0.a9 = 10; |
| a0.a10 = 11; |
| a0.a11 = 12; |
| a0.a12 = 13; |
| a0.a13 = 14; |
| a0.a14 = 15; |
| a0.a15 = 16; |
| a0.a16 = 17; |
| a0.a17 = 18; |
| a0.a18 = 19; |
| a0.a19 = 20; |
| a0.a20 = 21; |
| a0.a21 = 22; |
| a0.a22 = 23; |
| a0.a23 = 24; |
| a0.a24 = 25; |
| a0.a25 = 26; |
| a0.a26 = 27; |
| a0.a27 = 28; |
| a0.a28 = 29; |
| a0.a29 = 30; |
| a0.a30 = 31; |
| a0.a31 = 32; |
| a0.a32 = 33; |
| a0.a33 = 34; |
| a0.a34 = 35; |
| a0.a35 = 36; |
| a0.a36 = 37; |
| a0.a37 = 38; |
| a0.a38 = 39; |
| a0.a39 = 40; |
| a0.a40 = 41; |
| a0.a41 = 42; |
| a0.a42 = 43; |
| a0.a43 = 44; |
| a0.a44 = 45; |
| a0.a45 = 46; |
| a0.a46 = 47; |
| a0.a47 = 48; |
| a0.a48 = 49; |
| a0.a49 = 50; |
| a0.a50 = 51; |
| a0.a51 = 52; |
| a0.a52 = 53; |
| a0.a53 = 54; |
| a0.a54 = 55; |
| a0.a55 = 56; |
| a0.a56 = 57; |
| a0.a57 = 58; |
| a0.a58 = 59; |
| a0.a59 = 60; |
| a0.a60 = 61; |
| a0.a61 = 62; |
| a0.a62 = 63; |
| a0.a63 = 64; |
| a0.a64 = 65; |
| a0.a65 = 66; |
| a0.a66 = 67; |
| a0.a67 = 68; |
| a0.a68 = 69; |
| a0.a69 = 70; |
| a0.a70 = 71; |
| a0.a71 = 72; |
| a0.a72 = 73; |
| a0.a73 = 74; |
| a0.a74 = 75; |
| a0.a75 = 76; |
| a0.a76 = 77; |
| a0.a77 = 78; |
| a0.a78 = 79; |
| a0.a79 = 80; |
| a0.a80 = 81; |
| a0.a81 = 82; |
| a0.a82 = 83; |
| a0.a83 = 84; |
| a0.a84 = 85; |
| a0.a85 = 86; |
| a0.a86 = 87; |
| a0.a87 = 88; |
| a0.a88 = 89; |
| a0.a89 = 90; |
| a0.a90 = 91; |
| a0.a91 = 92; |
| a0.a92 = 93; |
| a0.a93 = 94; |
| a0.a94 = 95; |
| a0.a95 = 96; |
| a0.a96 = 97; |
| a0.a97 = 98; |
| a0.a98 = 99; |
| a0.a99 = 100; |
| a0.a100 = 101; |
| a0.a101 = 102; |
| a0.a102 = 103; |
| a0.a103 = 104; |
| a0.a104 = 105; |
| a0.a105 = 106; |
| a0.a106 = 107; |
| a0.a107 = 108; |
| a0.a108 = 109; |
| a0.a109 = 110; |
| a0.a110 = 111; |
| a0.a111 = 112; |
| a0.a112 = 113; |
| a0.a113 = 114; |
| a0.a114 = 115; |
| a0.a115 = 116; |
| a0.a116 = 117; |
| a0.a117 = 118; |
| a0.a118 = 119; |
| a0.a119 = 120; |
| a0.a120 = 121; |
| a0.a121 = 122; |
| a0.a122 = 123; |
| a0.a123 = 124; |
| a0.a124 = 125; |
| a0.a125 = 126; |
| a0.a126 = 127; |
| a0.a127 = 128; |
| |
| final result = passStruct1024BytesHomogeneousUint64NativeLeaf(a0); |
| |
| print("result = $result"); |
| |
| Expect.equals(8256, result); |
| |
| calloc.free(a0Pointer); |
| } |
| |
| @Native< |
| Float Function( |
| Float, |
| Struct16BytesHomogeneousFloat, |
| Float, |
| Struct16BytesHomogeneousFloat, |
| Float, |
| Struct16BytesHomogeneousFloat, |
| Float, |
| Struct16BytesHomogeneousFloat, |
| Float, |
| ) |
| >(symbol: 'PassFloatStruct16BytesHomogeneousFloatFloatStruct1', isLeaf: true) |
| external double passFloatStruct16BytesHomogeneousFloatFloatStruct1NativeLeaf( |
| double a0, |
| Struct16BytesHomogeneousFloat a1, |
| double a2, |
| Struct16BytesHomogeneousFloat a3, |
| double a4, |
| Struct16BytesHomogeneousFloat a5, |
| double a6, |
| Struct16BytesHomogeneousFloat a7, |
| double a8, |
| ); |
| |
| /// Tests the alignment of structs in FPU registers and backfilling. |
| void testPassFloatStruct16BytesHomogeneousFloatFloatStruct1NativeLeaf() { |
| double a0; |
| final a1Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a1 = a1Pointer.ref; |
| double a2; |
| final a3Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a3 = a3Pointer.ref; |
| double a4; |
| final a5Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a5 = a5Pointer.ref; |
| double a6; |
| final a7Pointer = calloc<Struct16BytesHomogeneousFloat>(); |
| final Struct16BytesHomogeneousFloat a7 = a7Pointer.ref; |
| double a8; |
| |
| a0 = -1.0; |
| a1.a0 = 2.0; |
| a1.a1 = -3.0; |
| a1.a2 = 4.0; |
| a1.a3 = -5.0; |
| a2 = 6.0; |
| a3.a0 = -7.0; |
| a3.a1 = 8.0; |
| a3.a2 = -9.0; |
| a3.a3 = 10.0; |
| a4 = -11.0; |
| a5.a0 = 12.0; |
| a5.a1 = -13.0; |
| a5.a2 = 14.0; |
| a5.a3 = -15.0; |
| a6 = 16.0; |
| a7.a0 = -17.0; |
| a7.a1 = 18.0; |
| a7.a2 = -19.0; |
| a7.a3 = 20.0; |
| a8 = -21.0; |
| |
| final result = passFloatStruct16BytesHomogeneousFloatFloatStruct1NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-11.0, result); |
| |
| calloc.free(a1Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a7Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Float, |
| Struct32BytesHomogeneousDouble, |
| Float, |
| Struct32BytesHomogeneousDouble, |
| Float, |
| Struct32BytesHomogeneousDouble, |
| Float, |
| Struct32BytesHomogeneousDouble, |
| Float, |
| ) |
| >(symbol: 'PassFloatStruct32BytesHomogeneousDoubleFloatStruct', isLeaf: true) |
| external double passFloatStruct32BytesHomogeneousDoubleFloatStructNativeLeaf( |
| double a0, |
| Struct32BytesHomogeneousDouble a1, |
| double a2, |
| Struct32BytesHomogeneousDouble a3, |
| double a4, |
| Struct32BytesHomogeneousDouble a5, |
| double a6, |
| Struct32BytesHomogeneousDouble a7, |
| double a8, |
| ); |
| |
| /// Tests the alignment of structs in FPU registers and backfilling. |
| void testPassFloatStruct32BytesHomogeneousDoubleFloatStructNativeLeaf() { |
| double a0; |
| final a1Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a1 = a1Pointer.ref; |
| double a2; |
| final a3Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a3 = a3Pointer.ref; |
| double a4; |
| final a5Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a5 = a5Pointer.ref; |
| double a6; |
| final a7Pointer = calloc<Struct32BytesHomogeneousDouble>(); |
| final Struct32BytesHomogeneousDouble a7 = a7Pointer.ref; |
| double a8; |
| |
| a0 = -1.0; |
| a1.a0 = 2.0; |
| a1.a1 = -3.0; |
| a1.a2 = 4.0; |
| a1.a3 = -5.0; |
| a2 = 6.0; |
| a3.a0 = -7.0; |
| a3.a1 = 8.0; |
| a3.a2 = -9.0; |
| a3.a3 = 10.0; |
| a4 = -11.0; |
| a5.a0 = 12.0; |
| a5.a1 = -13.0; |
| a5.a2 = 14.0; |
| a5.a3 = -15.0; |
| a6 = 16.0; |
| a7.a0 = -17.0; |
| a7.a1 = 18.0; |
| a7.a2 = -19.0; |
| a7.a3 = 20.0; |
| a8 = -21.0; |
| |
| final result = passFloatStruct32BytesHomogeneousDoubleFloatStructNativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-11.0, result); |
| |
| calloc.free(a1Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a7Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Int8, |
| Struct16BytesMixed, |
| Int8, |
| Struct16BytesMixed, |
| Int8, |
| Struct16BytesMixed, |
| Int8, |
| Struct16BytesMixed, |
| Int8, |
| ) |
| >(symbol: 'PassInt8Struct16BytesMixedInt8Struct16BytesMixedIn', isLeaf: true) |
| external double passInt8Struct16BytesMixedInt8Struct16BytesMixedInNativeLeaf( |
| int a0, |
| Struct16BytesMixed a1, |
| int a2, |
| Struct16BytesMixed a3, |
| int a4, |
| Struct16BytesMixed a5, |
| int a6, |
| Struct16BytesMixed a7, |
| int a8, |
| ); |
| |
| /// Tests the alignment of structs in integers registers and on the stack. |
| /// Arm32 aligns this struct at 8. |
| /// Also, arm32 allocates the second struct partially in registers, partially |
| /// on stack. |
| /// Test backfilling of integer registers. |
| void testPassInt8Struct16BytesMixedInt8Struct16BytesMixedInNativeLeaf() { |
| int a0; |
| final a1Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a1 = a1Pointer.ref; |
| int a2; |
| final a3Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a3 = a3Pointer.ref; |
| int a4; |
| final a5Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a5 = a5Pointer.ref; |
| int a6; |
| final a7Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a7 = a7Pointer.ref; |
| int a8; |
| |
| a0 = -1; |
| a1.a0 = 2.0; |
| a1.a1 = -3; |
| a2 = 4; |
| a3.a0 = -5.0; |
| a3.a1 = 6; |
| a4 = -7; |
| a5.a0 = 8.0; |
| a5.a1 = -9; |
| a6 = 10; |
| a7.a0 = -11.0; |
| a7.a1 = 12; |
| a8 = -13; |
| |
| final result = passInt8Struct16BytesMixedInt8Struct16BytesMixedInNativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-7.0, result); |
| |
| calloc.free(a1Pointer); |
| calloc.free(a3Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a7Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Int32, |
| ) |
| >(symbol: 'PassDoublex6Struct16BytesMixedx4Int32', isLeaf: true) |
| external double passDoublex6Struct16BytesMixedx4Int32NativeLeaf( |
| double a0, |
| double a1, |
| double a2, |
| double a3, |
| double a4, |
| double a5, |
| Struct16BytesMixed a6, |
| Struct16BytesMixed a7, |
| Struct16BytesMixed a8, |
| Struct16BytesMixed a9, |
| int a10, |
| ); |
| |
| /// On Linux x64, it will exhaust xmm registers first, after 6 doubles and 2 |
| /// structs. The rest of the structs will go on the stack. |
| /// The int will be backfilled into the int register. |
| void testPassDoublex6Struct16BytesMixedx4Int32NativeLeaf() { |
| double a0; |
| double a1; |
| double a2; |
| double a3; |
| double a4; |
| double a5; |
| final a6Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a7 = a7Pointer.ref; |
| final a8Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a8 = a8Pointer.ref; |
| final a9Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a9 = a9Pointer.ref; |
| int a10; |
| |
| a0 = -1.0; |
| a1 = 2.0; |
| a2 = -3.0; |
| a3 = 4.0; |
| a4 = -5.0; |
| a5 = 6.0; |
| a6.a0 = -7.0; |
| a6.a1 = 8; |
| a7.a0 = -9.0; |
| a7.a1 = 10; |
| a8.a0 = -11.0; |
| a8.a1 = 12; |
| a9.a0 = -13.0; |
| a9.a1 = 14; |
| a10 = -15; |
| |
| final result = passDoublex6Struct16BytesMixedx4Int32NativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| a9, |
| a10, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-8.0, result); |
| |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| calloc.free(a8Pointer); |
| calloc.free(a9Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Struct16BytesMixed, |
| Double, |
| ) |
| >(symbol: 'PassInt32x4Struct16BytesMixedx4Double', isLeaf: true) |
| external double passInt32x4Struct16BytesMixedx4DoubleNativeLeaf( |
| int a0, |
| int a1, |
| int a2, |
| int a3, |
| Struct16BytesMixed a4, |
| Struct16BytesMixed a5, |
| Struct16BytesMixed a6, |
| Struct16BytesMixed a7, |
| double a8, |
| ); |
| |
| /// On Linux x64, it will exhaust int registers first. |
| /// The rest of the structs will go on the stack. |
| /// The double will be backfilled into the xmm register. |
| void testPassInt32x4Struct16BytesMixedx4DoubleNativeLeaf() { |
| int a0; |
| int a1; |
| int a2; |
| int a3; |
| final a4Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a4 = a4Pointer.ref; |
| final a5Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a5 = a5Pointer.ref; |
| final a6Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a6 = a6Pointer.ref; |
| final a7Pointer = calloc<Struct16BytesMixed>(); |
| final Struct16BytesMixed a7 = a7Pointer.ref; |
| double a8; |
| |
| a0 = -1; |
| a1 = 2; |
| a2 = -3; |
| a3 = 4; |
| a4.a0 = -5.0; |
| a4.a1 = 6; |
| a5.a0 = -7.0; |
| a5.a1 = 8; |
| a6.a0 = -9.0; |
| a6.a1 = 10; |
| a7.a0 = -11.0; |
| a7.a1 = 12; |
| a8 = -13.0; |
| |
| final result = passInt32x4Struct16BytesMixedx4DoubleNativeLeaf( |
| a0, |
| a1, |
| a2, |
| a3, |
| a4, |
| a5, |
| a6, |
| a7, |
| a8, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-7.0, result); |
| |
| calloc.free(a4Pointer); |
| calloc.free(a5Pointer); |
| calloc.free(a6Pointer); |
| calloc.free(a7Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Struct40BytesHomogeneousDouble, |
| Struct4BytesHomogeneousInt16, |
| Struct8BytesHomogeneousFloat, |
| ) |
| >(symbol: 'PassStruct40BytesHomogeneousDoubleStruct4BytesHomo', isLeaf: true) |
| external double passStruct40BytesHomogeneousDoubleStruct4BytesHomoNativeLeaf( |
| Struct40BytesHomogeneousDouble a0, |
| Struct4BytesHomogeneousInt16 a1, |
| Struct8BytesHomogeneousFloat a2, |
| ); |
| |
| /// On various architectures, first struct is allocated on stack. |
| /// Check that the other two arguments are allocated on registers. |
| void testPassStruct40BytesHomogeneousDoubleStruct4BytesHomoNativeLeaf() { |
| final a0Pointer = calloc<Struct40BytesHomogeneousDouble>(); |
| final Struct40BytesHomogeneousDouble a0 = a0Pointer.ref; |
| final a1Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a1 = a1Pointer.ref; |
| final a2Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a2 = a2Pointer.ref; |
| |
| a0.a0 = -1.0; |
| a0.a1 = 2.0; |
| a0.a2 = -3.0; |
| a0.a3 = 4.0; |
| a0.a4 = -5.0; |
| a1.a0 = 6; |
| a1.a1 = -7; |
| a2.a0 = 8.0; |
| a2.a1 = -9.0; |
| |
| final result = passStruct40BytesHomogeneousDoubleStruct4BytesHomoNativeLeaf( |
| a0, |
| a1, |
| a2, |
| ); |
| |
| print("result = $result"); |
| |
| Expect.approxEquals(-5.0, result); |
| |
| calloc.free(a0Pointer); |
| calloc.free(a1Pointer); |
| calloc.free(a2Pointer); |
| } |
| |
| @Native< |
| Double Function( |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Int32, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Double, |
| Int64, |
| Int8, |
| Struct1ByteInt, |
| Int64, |
| Int8, |
| Struct4BytesHomogeneousInt16, |
| Int64, |
| Int8, |
| Struct8BytesInt, |
| Int64, |
| Int8, |
| Struct8BytesHomogeneousFloat, |
| Int64, |
| Int8, |
| Struct8BytesMixed, |
| Int64, |
| Int8, |
| StructAlignmentInt16, |
| Int64, |
| Int8, |
| StructAlignmentInt32, |
| Int64, |
| Int8, |
| StructAlignmentInt64, |
| ) |
| >(symbol: 'PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int', isLeaf: true) |
| external double passInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntNativeLeaf( |
| int a0, |
| int a1, |
| int a2, |
| int a3, |
| int a4, |
| int a5, |
| int a6, |
| int a7, |
| double a8, |
| double a9, |
| double a10, |
| double a11, |
| double a12, |
| double a13, |
| double a14, |
| double a15, |
| int a16, |
| int a17, |
| Struct1ByteInt a18, |
| int a19, |
| int a20, |
| Struct4BytesHomogeneousInt16 a21, |
| int a22, |
| int a23, |
| Struct8BytesInt a24, |
| int a25, |
| int a26, |
| Struct8BytesHomogeneousFloat a27, |
| int a28, |
| int a29, |
| Struct8BytesMixed a30, |
| int a31, |
| int a32, |
| StructAlignmentInt16 a33, |
| int a34, |
| int a35, |
| StructAlignmentInt32 a36, |
| int a37, |
| int a38, |
| StructAlignmentInt64 a39, |
| ); |
| |
| /// Test alignment and padding of 16 byte int within struct. |
| void testPassInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntNativeLeaf() { |
| int a0; |
| int a1; |
| int a2; |
| int a3; |
| int a4; |
| int a5; |
| int a6; |
| int a7; |
| double a8; |
| double a9; |
| double a10; |
| double a11; |
| double a12; |
| double a13; |
| double a14; |
| double a15; |
| int a16; |
| int a17; |
| final a18Pointer = calloc<Struct1ByteInt>(); |
| final Struct1ByteInt a18 = a18Pointer.ref; |
| int a19; |
| int a20; |
| final a21Pointer = calloc<Struct4BytesHomogeneousInt16>(); |
| final Struct4BytesHomogeneousInt16 a21 = a21Pointer.ref; |
| int a22; |
| int a23; |
| final a24Pointer = calloc<Struct8BytesInt>(); |
| final Struct8BytesInt a24 = a24Pointer.ref; |
| int a25; |
| int a26; |
| final a27Pointer = calloc<Struct8BytesHomogeneousFloat>(); |
| final Struct8BytesHomogeneousFloat a27 = a27Pointer.ref; |
| int a28; |
| |