mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 03:56:57 +00:00
13ec07415b
More details about the design: https://docs.google.com/document/d/1QDjyY_6wOTOgURwpeYMKU9qEz0gKxx2MUrdruC6Kp6c/edit?usp=sharing Change-Id: Ie3985d86dca7f5010044ca46c33ca177588c0f69 Bug: #37022 CoreLibraryReviewExempt: Reviewed by vm and api groups. web and wasm groups not affected because FFI isn't on those platforms. TEST=async_void_function_callbacks_test.dart, ffi_callback_metadata_test.cc, other front end tests Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/305900 Commit-Queue: Liam Appelbe <liama@google.com> Reviewed-by: Alexander Markov <alexmarkov@google.com> Reviewed-by: Lasse Nielsen <lrn@google.com> Reviewed-by: Daco Harkes <dacoharkes@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com> Reviewed-by: Ryan Macnak <rmacnak@google.com>
7006 lines
195 KiB
Dart
7006 lines
195 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=20
|
|
// VMOptions=--use-slow-path
|
|
// VMOptions=--use-slow-path --stacktrace-every=100
|
|
|
|
import 'dart:async';
|
|
import 'dart:ffi';
|
|
|
|
import "package:expect/expect.dart";
|
|
import "package:ffi/ffi.dart";
|
|
|
|
import 'async_callback_tests_utils.dart';
|
|
|
|
import 'dylib_utils.dart';
|
|
|
|
// Reuse the compound classes.
|
|
import 'function_structs_by_value_generated_compounds.dart';
|
|
|
|
final ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");
|
|
|
|
Future<void> main() async {
|
|
for (final t in testCases) {
|
|
print("==== Running " + t.name);
|
|
await t.run();
|
|
}
|
|
}
|
|
|
|
final testCases = [
|
|
AsyncCallbackTest(
|
|
"PassStruct1ByteIntx10",
|
|
Pointer.fromFunction<PassStruct1ByteIntx10Type>(passStruct1ByteIntx10),
|
|
passStruct1ByteIntx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct3BytesHomogeneousUint8x10",
|
|
Pointer.fromFunction<PassStruct3BytesHomogeneousUint8x10Type>(
|
|
passStruct3BytesHomogeneousUint8x10),
|
|
passStruct3BytesHomogeneousUint8x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct3BytesInt2ByteAlignedx10",
|
|
Pointer.fromFunction<PassStruct3BytesInt2ByteAlignedx10Type>(
|
|
passStruct3BytesInt2ByteAlignedx10),
|
|
passStruct3BytesInt2ByteAlignedx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct4BytesHomogeneousInt16x10",
|
|
Pointer.fromFunction<PassStruct4BytesHomogeneousInt16x10Type>(
|
|
passStruct4BytesHomogeneousInt16x10),
|
|
passStruct4BytesHomogeneousInt16x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct7BytesHomogeneousUint8x10",
|
|
Pointer.fromFunction<PassStruct7BytesHomogeneousUint8x10Type>(
|
|
passStruct7BytesHomogeneousUint8x10),
|
|
passStruct7BytesHomogeneousUint8x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct7BytesInt4ByteAlignedx10",
|
|
Pointer.fromFunction<PassStruct7BytesInt4ByteAlignedx10Type>(
|
|
passStruct7BytesInt4ByteAlignedx10),
|
|
passStruct7BytesInt4ByteAlignedx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesIntx10",
|
|
Pointer.fromFunction<PassStruct8BytesIntx10Type>(passStruct8BytesIntx10),
|
|
passStruct8BytesIntx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesHomogeneousFloatx10",
|
|
Pointer.fromFunction<PassStruct8BytesHomogeneousFloatx10Type>(
|
|
passStruct8BytesHomogeneousFloatx10),
|
|
passStruct8BytesHomogeneousFloatx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesMixedx10",
|
|
Pointer.fromFunction<PassStruct8BytesMixedx10Type>(
|
|
passStruct8BytesMixedx10),
|
|
passStruct8BytesMixedx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct9BytesHomogeneousUint8x10",
|
|
Pointer.fromFunction<PassStruct9BytesHomogeneousUint8x10Type>(
|
|
passStruct9BytesHomogeneousUint8x10),
|
|
passStruct9BytesHomogeneousUint8x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct9BytesInt4Or8ByteAlignedx10",
|
|
Pointer.fromFunction<PassStruct9BytesInt4Or8ByteAlignedx10Type>(
|
|
passStruct9BytesInt4Or8ByteAlignedx10),
|
|
passStruct9BytesInt4Or8ByteAlignedx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct12BytesHomogeneousFloatx6",
|
|
Pointer.fromFunction<PassStruct12BytesHomogeneousFloatx6Type>(
|
|
passStruct12BytesHomogeneousFloatx6),
|
|
passStruct12BytesHomogeneousFloatx6AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct16BytesHomogeneousFloatx5",
|
|
Pointer.fromFunction<PassStruct16BytesHomogeneousFloatx5Type>(
|
|
passStruct16BytesHomogeneousFloatx5),
|
|
passStruct16BytesHomogeneousFloatx5AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct16BytesMixedx10",
|
|
Pointer.fromFunction<PassStruct16BytesMixedx10Type>(
|
|
passStruct16BytesMixedx10),
|
|
passStruct16BytesMixedx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct16BytesMixed2x10",
|
|
Pointer.fromFunction<PassStruct16BytesMixed2x10Type>(
|
|
passStruct16BytesMixed2x10),
|
|
passStruct16BytesMixed2x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct17BytesIntx10",
|
|
Pointer.fromFunction<PassStruct17BytesIntx10Type>(
|
|
passStruct17BytesIntx10),
|
|
passStruct17BytesIntx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct19BytesHomogeneousUint8x10",
|
|
Pointer.fromFunction<PassStruct19BytesHomogeneousUint8x10Type>(
|
|
passStruct19BytesHomogeneousUint8x10),
|
|
passStruct19BytesHomogeneousUint8x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct20BytesHomogeneousInt32x10",
|
|
Pointer.fromFunction<PassStruct20BytesHomogeneousInt32x10Type>(
|
|
passStruct20BytesHomogeneousInt32x10),
|
|
passStruct20BytesHomogeneousInt32x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct20BytesHomogeneousFloat",
|
|
Pointer.fromFunction<PassStruct20BytesHomogeneousFloatType>(
|
|
passStruct20BytesHomogeneousFloat),
|
|
passStruct20BytesHomogeneousFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct32BytesHomogeneousDoublex5",
|
|
Pointer.fromFunction<PassStruct32BytesHomogeneousDoublex5Type>(
|
|
passStruct32BytesHomogeneousDoublex5),
|
|
passStruct32BytesHomogeneousDoublex5AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct40BytesHomogeneousDouble",
|
|
Pointer.fromFunction<PassStruct40BytesHomogeneousDoubleType>(
|
|
passStruct40BytesHomogeneousDouble),
|
|
passStruct40BytesHomogeneousDoubleAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct1024BytesHomogeneousUint64",
|
|
Pointer.fromFunction<PassStruct1024BytesHomogeneousUint64Type>(
|
|
passStruct1024BytesHomogeneousUint64),
|
|
passStruct1024BytesHomogeneousUint64AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassFloatStruct16BytesHomogeneousFloatFloatStruct1",
|
|
Pointer.fromFunction<
|
|
PassFloatStruct16BytesHomogeneousFloatFloatStruct1Type>(
|
|
passFloatStruct16BytesHomogeneousFloatFloatStruct1),
|
|
passFloatStruct16BytesHomogeneousFloatFloatStruct1AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassFloatStruct32BytesHomogeneousDoubleFloatStruct",
|
|
Pointer.fromFunction<
|
|
PassFloatStruct32BytesHomogeneousDoubleFloatStructType>(
|
|
passFloatStruct32BytesHomogeneousDoubleFloatStruct),
|
|
passFloatStruct32BytesHomogeneousDoubleFloatStructAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassInt8Struct16BytesMixedInt8Struct16BytesMixedIn",
|
|
Pointer.fromFunction<
|
|
PassInt8Struct16BytesMixedInt8Struct16BytesMixedInType>(
|
|
passInt8Struct16BytesMixedInt8Struct16BytesMixedIn),
|
|
passInt8Struct16BytesMixedInt8Struct16BytesMixedInAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassDoublex6Struct16BytesMixedx4Int32",
|
|
Pointer.fromFunction<PassDoublex6Struct16BytesMixedx4Int32Type>(
|
|
passDoublex6Struct16BytesMixedx4Int32),
|
|
passDoublex6Struct16BytesMixedx4Int32AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassInt32x4Struct16BytesMixedx4Double",
|
|
Pointer.fromFunction<PassInt32x4Struct16BytesMixedx4DoubleType>(
|
|
passInt32x4Struct16BytesMixedx4Double),
|
|
passInt32x4Struct16BytesMixedx4DoubleAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct40BytesHomogeneousDoubleStruct4BytesHomo",
|
|
Pointer.fromFunction<
|
|
PassStruct40BytesHomogeneousDoubleStruct4BytesHomoType>(
|
|
passStruct40BytesHomogeneousDoubleStruct4BytesHomo),
|
|
passStruct40BytesHomogeneousDoubleStruct4BytesHomoAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int",
|
|
Pointer.fromFunction<
|
|
PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntType>(
|
|
passInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int),
|
|
passInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructAlignmentInt16",
|
|
Pointer.fromFunction<PassStructAlignmentInt16Type>(
|
|
passStructAlignmentInt16),
|
|
passStructAlignmentInt16AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructAlignmentInt32",
|
|
Pointer.fromFunction<PassStructAlignmentInt32Type>(
|
|
passStructAlignmentInt32),
|
|
passStructAlignmentInt32AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructAlignmentInt64",
|
|
Pointer.fromFunction<PassStructAlignmentInt64Type>(
|
|
passStructAlignmentInt64),
|
|
passStructAlignmentInt64AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesNestedIntx10",
|
|
Pointer.fromFunction<PassStruct8BytesNestedIntx10Type>(
|
|
passStruct8BytesNestedIntx10),
|
|
passStruct8BytesNestedIntx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesNestedFloatx10",
|
|
Pointer.fromFunction<PassStruct8BytesNestedFloatx10Type>(
|
|
passStruct8BytesNestedFloatx10),
|
|
passStruct8BytesNestedFloatx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesNestedFloat2x10",
|
|
Pointer.fromFunction<PassStruct8BytesNestedFloat2x10Type>(
|
|
passStruct8BytesNestedFloat2x10),
|
|
passStruct8BytesNestedFloat2x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesNestedMixedx10",
|
|
Pointer.fromFunction<PassStruct8BytesNestedMixedx10Type>(
|
|
passStruct8BytesNestedMixedx10),
|
|
passStruct8BytesNestedMixedx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct16BytesNestedIntx2",
|
|
Pointer.fromFunction<PassStruct16BytesNestedIntx2Type>(
|
|
passStruct16BytesNestedIntx2),
|
|
passStruct16BytesNestedIntx2AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct32BytesNestedIntx2",
|
|
Pointer.fromFunction<PassStruct32BytesNestedIntx2Type>(
|
|
passStruct32BytesNestedIntx2),
|
|
passStruct32BytesNestedIntx2AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructNestedIntStructAlignmentInt16",
|
|
Pointer.fromFunction<PassStructNestedIntStructAlignmentInt16Type>(
|
|
passStructNestedIntStructAlignmentInt16),
|
|
passStructNestedIntStructAlignmentInt16AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructNestedIntStructAlignmentInt32",
|
|
Pointer.fromFunction<PassStructNestedIntStructAlignmentInt32Type>(
|
|
passStructNestedIntStructAlignmentInt32),
|
|
passStructNestedIntStructAlignmentInt32AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructNestedIntStructAlignmentInt64",
|
|
Pointer.fromFunction<PassStructNestedIntStructAlignmentInt64Type>(
|
|
passStructNestedIntStructAlignmentInt64),
|
|
passStructNestedIntStructAlignmentInt64AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructNestedIrregularEvenBiggerx4",
|
|
Pointer.fromFunction<PassStructNestedIrregularEvenBiggerx4Type>(
|
|
passStructNestedIrregularEvenBiggerx4),
|
|
passStructNestedIrregularEvenBiggerx4AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesInlineArrayIntx4",
|
|
Pointer.fromFunction<PassStruct8BytesInlineArrayIntx4Type>(
|
|
passStruct8BytesInlineArrayIntx4),
|
|
passStruct8BytesInlineArrayIntx4AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructInlineArrayIrregularx4",
|
|
Pointer.fromFunction<PassStructInlineArrayIrregularx4Type>(
|
|
passStructInlineArrayIrregularx4),
|
|
passStructInlineArrayIrregularx4AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructInlineArray100Bytes",
|
|
Pointer.fromFunction<PassStructInlineArray100BytesType>(
|
|
passStructInlineArray100Bytes),
|
|
passStructInlineArray100BytesAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructStruct16BytesHomogeneousFloat2x5",
|
|
Pointer.fromFunction<PassStructStruct16BytesHomogeneousFloat2x5Type>(
|
|
passStructStruct16BytesHomogeneousFloat2x5),
|
|
passStructStruct16BytesHomogeneousFloat2x5AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructStruct32BytesHomogeneousDouble2x5",
|
|
Pointer.fromFunction<PassStructStruct32BytesHomogeneousDouble2x5Type>(
|
|
passStructStruct32BytesHomogeneousDouble2x5),
|
|
passStructStruct32BytesHomogeneousDouble2x5AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructStruct16BytesMixed3x10",
|
|
Pointer.fromFunction<PassStructStruct16BytesMixed3x10Type>(
|
|
passStructStruct16BytesMixed3x10),
|
|
passStructStruct16BytesMixed3x10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUint8Struct32BytesInlineArrayMultiDimensionalI",
|
|
Pointer.fromFunction<
|
|
PassUint8Struct32BytesInlineArrayMultiDimensionalIType>(
|
|
passUint8Struct32BytesInlineArrayMultiDimensionalI),
|
|
passUint8Struct32BytesInlineArrayMultiDimensionalIAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUint8Struct4BytesInlineArrayMultiDimensionalIn",
|
|
Pointer.fromFunction<
|
|
PassUint8Struct4BytesInlineArrayMultiDimensionalInType>(
|
|
passUint8Struct4BytesInlineArrayMultiDimensionalIn),
|
|
passUint8Struct4BytesInlineArrayMultiDimensionalInAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct3BytesPackedIntx10",
|
|
Pointer.fromFunction<PassStruct3BytesPackedIntx10Type>(
|
|
passStruct3BytesPackedIntx10),
|
|
passStruct3BytesPackedIntx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct8BytesPackedIntx10",
|
|
Pointer.fromFunction<PassStruct8BytesPackedIntx10Type>(
|
|
passStruct8BytesPackedIntx10),
|
|
passStruct8BytesPackedIntx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct9BytesPackedMixedx10DoubleInt32x2",
|
|
Pointer.fromFunction<PassStruct9BytesPackedMixedx10DoubleInt32x2Type>(
|
|
passStruct9BytesPackedMixedx10DoubleInt32x2),
|
|
passStruct9BytesPackedMixedx10DoubleInt32x2AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct5BytesPackedMixed",
|
|
Pointer.fromFunction<PassStruct5BytesPackedMixedType>(
|
|
passStruct5BytesPackedMixed),
|
|
passStruct5BytesPackedMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStructNestedAlignmentStruct5BytesPackedMixed",
|
|
Pointer.fromFunction<
|
|
PassStructNestedAlignmentStruct5BytesPackedMixedType>(
|
|
passStructNestedAlignmentStruct5BytesPackedMixed),
|
|
passStructNestedAlignmentStruct5BytesPackedMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct6BytesInlineArrayInt",
|
|
Pointer.fromFunction<PassStruct6BytesInlineArrayIntType>(
|
|
passStruct6BytesInlineArrayInt),
|
|
passStruct6BytesInlineArrayIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassStruct15BytesInlineArrayMixed",
|
|
Pointer.fromFunction<PassStruct15BytesInlineArrayMixedType>(
|
|
passStruct15BytesInlineArrayMixed),
|
|
passStruct15BytesInlineArrayMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUnion4BytesMixedx10",
|
|
Pointer.fromFunction<PassUnion4BytesMixedx10Type>(
|
|
passUnion4BytesMixedx10),
|
|
passUnion4BytesMixedx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUnion8BytesNestedFloatx10",
|
|
Pointer.fromFunction<PassUnion8BytesNestedFloatx10Type>(
|
|
passUnion8BytesNestedFloatx10),
|
|
passUnion8BytesNestedFloatx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUnion9BytesNestedIntx10",
|
|
Pointer.fromFunction<PassUnion9BytesNestedIntx10Type>(
|
|
passUnion9BytesNestedIntx10),
|
|
passUnion9BytesNestedIntx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUnion16BytesNestedInlineArrayFloatx10",
|
|
Pointer.fromFunction<PassUnion16BytesNestedInlineArrayFloatx10Type>(
|
|
passUnion16BytesNestedInlineArrayFloatx10),
|
|
passUnion16BytesNestedInlineArrayFloatx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUnion16BytesNestedFloatx10",
|
|
Pointer.fromFunction<PassUnion16BytesNestedFloatx10Type>(
|
|
passUnion16BytesNestedFloatx10),
|
|
passUnion16BytesNestedFloatx10AfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUint8Boolx9Struct10BytesHomogeneousBoolBool",
|
|
Pointer.fromFunction<PassUint8Boolx9Struct10BytesHomogeneousBoolBoolType>(
|
|
passUint8Boolx9Struct10BytesHomogeneousBoolBool),
|
|
passUint8Boolx9Struct10BytesHomogeneousBoolBoolAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUint8Boolx9Struct10BytesInlineArrayBoolBool",
|
|
Pointer.fromFunction<PassUint8Boolx9Struct10BytesInlineArrayBoolBoolType>(
|
|
passUint8Boolx9Struct10BytesInlineArrayBoolBool),
|
|
passUint8Boolx9Struct10BytesInlineArrayBoolBoolAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassUint8Struct1ByteBool",
|
|
Pointer.fromFunction<PassUint8Struct1ByteBoolType>(
|
|
passUint8Struct1ByteBool),
|
|
passUint8Struct1ByteBoolAfterCallback),
|
|
AsyncCallbackTest(
|
|
"PassWCharStructInlineArrayIntUintPtrx2LongUnsigned",
|
|
Pointer.fromFunction<
|
|
PassWCharStructInlineArrayIntUintPtrx2LongUnsignedType>(
|
|
passWCharStructInlineArrayIntUintPtrx2LongUnsigned),
|
|
passWCharStructInlineArrayIntUintPtrx2LongUnsignedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct1ByteInt",
|
|
Pointer.fromFunction<ReturnStruct1ByteIntType>(returnStruct1ByteInt),
|
|
returnStruct1ByteIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct3BytesHomogeneousUint8",
|
|
Pointer.fromFunction<ReturnStruct3BytesHomogeneousUint8Type>(
|
|
returnStruct3BytesHomogeneousUint8),
|
|
returnStruct3BytesHomogeneousUint8AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct3BytesInt2ByteAligned",
|
|
Pointer.fromFunction<ReturnStruct3BytesInt2ByteAlignedType>(
|
|
returnStruct3BytesInt2ByteAligned),
|
|
returnStruct3BytesInt2ByteAlignedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct4BytesHomogeneousInt16",
|
|
Pointer.fromFunction<ReturnStruct4BytesHomogeneousInt16Type>(
|
|
returnStruct4BytesHomogeneousInt16),
|
|
returnStruct4BytesHomogeneousInt16AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct7BytesHomogeneousUint8",
|
|
Pointer.fromFunction<ReturnStruct7BytesHomogeneousUint8Type>(
|
|
returnStruct7BytesHomogeneousUint8),
|
|
returnStruct7BytesHomogeneousUint8AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct7BytesInt4ByteAligned",
|
|
Pointer.fromFunction<ReturnStruct7BytesInt4ByteAlignedType>(
|
|
returnStruct7BytesInt4ByteAligned),
|
|
returnStruct7BytesInt4ByteAlignedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesInt",
|
|
Pointer.fromFunction<ReturnStruct8BytesIntType>(returnStruct8BytesInt),
|
|
returnStruct8BytesIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesHomogeneousFloat",
|
|
Pointer.fromFunction<ReturnStruct8BytesHomogeneousFloatType>(
|
|
returnStruct8BytesHomogeneousFloat),
|
|
returnStruct8BytesHomogeneousFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesMixed",
|
|
Pointer.fromFunction<ReturnStruct8BytesMixedType>(
|
|
returnStruct8BytesMixed),
|
|
returnStruct8BytesMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct9BytesHomogeneousUint8",
|
|
Pointer.fromFunction<ReturnStruct9BytesHomogeneousUint8Type>(
|
|
returnStruct9BytesHomogeneousUint8),
|
|
returnStruct9BytesHomogeneousUint8AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct9BytesInt4Or8ByteAligned",
|
|
Pointer.fromFunction<ReturnStruct9BytesInt4Or8ByteAlignedType>(
|
|
returnStruct9BytesInt4Or8ByteAligned),
|
|
returnStruct9BytesInt4Or8ByteAlignedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct12BytesHomogeneousFloat",
|
|
Pointer.fromFunction<ReturnStruct12BytesHomogeneousFloatType>(
|
|
returnStruct12BytesHomogeneousFloat),
|
|
returnStruct12BytesHomogeneousFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct16BytesHomogeneousFloat",
|
|
Pointer.fromFunction<ReturnStruct16BytesHomogeneousFloatType>(
|
|
returnStruct16BytesHomogeneousFloat),
|
|
returnStruct16BytesHomogeneousFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct16BytesMixed",
|
|
Pointer.fromFunction<ReturnStruct16BytesMixedType>(
|
|
returnStruct16BytesMixed),
|
|
returnStruct16BytesMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct16BytesMixed2",
|
|
Pointer.fromFunction<ReturnStruct16BytesMixed2Type>(
|
|
returnStruct16BytesMixed2),
|
|
returnStruct16BytesMixed2AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct17BytesInt",
|
|
Pointer.fromFunction<ReturnStruct17BytesIntType>(returnStruct17BytesInt),
|
|
returnStruct17BytesIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct19BytesHomogeneousUint8",
|
|
Pointer.fromFunction<ReturnStruct19BytesHomogeneousUint8Type>(
|
|
returnStruct19BytesHomogeneousUint8),
|
|
returnStruct19BytesHomogeneousUint8AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct20BytesHomogeneousInt32",
|
|
Pointer.fromFunction<ReturnStruct20BytesHomogeneousInt32Type>(
|
|
returnStruct20BytesHomogeneousInt32),
|
|
returnStruct20BytesHomogeneousInt32AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct20BytesHomogeneousFloat",
|
|
Pointer.fromFunction<ReturnStruct20BytesHomogeneousFloatType>(
|
|
returnStruct20BytesHomogeneousFloat),
|
|
returnStruct20BytesHomogeneousFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct32BytesHomogeneousDouble",
|
|
Pointer.fromFunction<ReturnStruct32BytesHomogeneousDoubleType>(
|
|
returnStruct32BytesHomogeneousDouble),
|
|
returnStruct32BytesHomogeneousDoubleAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct40BytesHomogeneousDouble",
|
|
Pointer.fromFunction<ReturnStruct40BytesHomogeneousDoubleType>(
|
|
returnStruct40BytesHomogeneousDouble),
|
|
returnStruct40BytesHomogeneousDoubleAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct1024BytesHomogeneousUint64",
|
|
Pointer.fromFunction<ReturnStruct1024BytesHomogeneousUint64Type>(
|
|
returnStruct1024BytesHomogeneousUint64),
|
|
returnStruct1024BytesHomogeneousUint64AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct3BytesPackedInt",
|
|
Pointer.fromFunction<ReturnStruct3BytesPackedIntType>(
|
|
returnStruct3BytesPackedInt),
|
|
returnStruct3BytesPackedIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesPackedInt",
|
|
Pointer.fromFunction<ReturnStruct8BytesPackedIntType>(
|
|
returnStruct8BytesPackedInt),
|
|
returnStruct8BytesPackedIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct9BytesPackedMixed",
|
|
Pointer.fromFunction<ReturnStruct9BytesPackedMixedType>(
|
|
returnStruct9BytesPackedMixed),
|
|
returnStruct9BytesPackedMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnUnion4BytesMixed",
|
|
Pointer.fromFunction<ReturnUnion4BytesMixedType>(returnUnion4BytesMixed),
|
|
returnUnion4BytesMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnUnion8BytesNestedFloat",
|
|
Pointer.fromFunction<ReturnUnion8BytesNestedFloatType>(
|
|
returnUnion8BytesNestedFloat),
|
|
returnUnion8BytesNestedFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnUnion9BytesNestedInt",
|
|
Pointer.fromFunction<ReturnUnion9BytesNestedIntType>(
|
|
returnUnion9BytesNestedInt),
|
|
returnUnion9BytesNestedIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnUnion16BytesNestedFloat",
|
|
Pointer.fromFunction<ReturnUnion16BytesNestedFloatType>(
|
|
returnUnion16BytesNestedFloat),
|
|
returnUnion16BytesNestedFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentStruct1ByteInt",
|
|
Pointer.fromFunction<ReturnStructArgumentStruct1ByteIntType>(
|
|
returnStructArgumentStruct1ByteInt),
|
|
returnStructArgumentStruct1ByteIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentInt32x8Struct1ByteInt",
|
|
Pointer.fromFunction<ReturnStructArgumentInt32x8Struct1ByteIntType>(
|
|
returnStructArgumentInt32x8Struct1ByteInt),
|
|
returnStructArgumentInt32x8Struct1ByteIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentStruct8BytesHomogeneousFloat",
|
|
Pointer.fromFunction<
|
|
ReturnStructArgumentStruct8BytesHomogeneousFloatType>(
|
|
returnStructArgumentStruct8BytesHomogeneousFloat),
|
|
returnStructArgumentStruct8BytesHomogeneousFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentStruct20BytesHomogeneousInt32",
|
|
Pointer.fromFunction<
|
|
ReturnStructArgumentStruct20BytesHomogeneousInt32Type>(
|
|
returnStructArgumentStruct20BytesHomogeneousInt32),
|
|
returnStructArgumentStruct20BytesHomogeneousInt32AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentInt32x8Struct20BytesHomogeneou",
|
|
Pointer.fromFunction<
|
|
ReturnStructArgumentInt32x8Struct20BytesHomogeneouType>(
|
|
returnStructArgumentInt32x8Struct20BytesHomogeneou),
|
|
returnStructArgumentInt32x8Struct20BytesHomogeneouAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentStruct8BytesInlineArrayInt",
|
|
Pointer.fromFunction<ReturnStructArgumentStruct8BytesInlineArrayIntType>(
|
|
returnStructArgumentStruct8BytesInlineArrayInt),
|
|
returnStructArgumentStruct8BytesInlineArrayIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentStructStruct16BytesHomogeneous",
|
|
Pointer.fromFunction<
|
|
ReturnStructArgumentStructStruct16BytesHomogeneousType>(
|
|
returnStructArgumentStructStruct16BytesHomogeneous),
|
|
returnStructArgumentStructStruct16BytesHomogeneousAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentStructStruct32BytesHomogeneous",
|
|
Pointer.fromFunction<
|
|
ReturnStructArgumentStructStruct32BytesHomogeneousType>(
|
|
returnStructArgumentStructStruct32BytesHomogeneous),
|
|
returnStructArgumentStructStruct32BytesHomogeneousAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructArgumentStructStruct16BytesMixed3",
|
|
Pointer.fromFunction<ReturnStructArgumentStructStruct16BytesMixed3Type>(
|
|
returnStructArgumentStructStruct16BytesMixed3),
|
|
returnStructArgumentStructStruct16BytesMixed3AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructAlignmentInt16",
|
|
Pointer.fromFunction<ReturnStructAlignmentInt16Type>(
|
|
returnStructAlignmentInt16),
|
|
returnStructAlignmentInt16AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructAlignmentInt32",
|
|
Pointer.fromFunction<ReturnStructAlignmentInt32Type>(
|
|
returnStructAlignmentInt32),
|
|
returnStructAlignmentInt32AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructAlignmentInt64",
|
|
Pointer.fromFunction<ReturnStructAlignmentInt64Type>(
|
|
returnStructAlignmentInt64),
|
|
returnStructAlignmentInt64AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesNestedInt",
|
|
Pointer.fromFunction<ReturnStruct8BytesNestedIntType>(
|
|
returnStruct8BytesNestedInt),
|
|
returnStruct8BytesNestedIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesNestedFloat",
|
|
Pointer.fromFunction<ReturnStruct8BytesNestedFloatType>(
|
|
returnStruct8BytesNestedFloat),
|
|
returnStruct8BytesNestedFloatAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesNestedFloat2",
|
|
Pointer.fromFunction<ReturnStruct8BytesNestedFloat2Type>(
|
|
returnStruct8BytesNestedFloat2),
|
|
returnStruct8BytesNestedFloat2AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct8BytesNestedMixed",
|
|
Pointer.fromFunction<ReturnStruct8BytesNestedMixedType>(
|
|
returnStruct8BytesNestedMixed),
|
|
returnStruct8BytesNestedMixedAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct16BytesNestedInt",
|
|
Pointer.fromFunction<ReturnStruct16BytesNestedIntType>(
|
|
returnStruct16BytesNestedInt),
|
|
returnStruct16BytesNestedIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStruct32BytesNestedInt",
|
|
Pointer.fromFunction<ReturnStruct32BytesNestedIntType>(
|
|
returnStruct32BytesNestedInt),
|
|
returnStruct32BytesNestedIntAfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructNestedIntStructAlignmentInt16",
|
|
Pointer.fromFunction<ReturnStructNestedIntStructAlignmentInt16Type>(
|
|
returnStructNestedIntStructAlignmentInt16),
|
|
returnStructNestedIntStructAlignmentInt16AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructNestedIntStructAlignmentInt32",
|
|
Pointer.fromFunction<ReturnStructNestedIntStructAlignmentInt32Type>(
|
|
returnStructNestedIntStructAlignmentInt32),
|
|
returnStructNestedIntStructAlignmentInt32AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructNestedIntStructAlignmentInt64",
|
|
Pointer.fromFunction<ReturnStructNestedIntStructAlignmentInt64Type>(
|
|
returnStructNestedIntStructAlignmentInt64),
|
|
returnStructNestedIntStructAlignmentInt64AfterCallback),
|
|
AsyncCallbackTest(
|
|
"ReturnStructNestedIrregularEvenBigger",
|
|
Pointer.fromFunction<ReturnStructNestedIrregularEvenBiggerType>(
|
|
returnStructNestedIrregularEvenBigger),
|
|
returnStructNestedIrregularEvenBiggerAfterCallback),
|
|
];
|
|
typedef PassStruct1ByteIntx10Type = Void Function(
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt,
|
|
Struct1ByteInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct1ByteIntx10Result = Completer<double>();
|
|
|
|
/// Smallest struct with data.
|
|
/// 10 struct arguments will exhaust available registers.
|
|
void passStruct1ByteIntx10(
|
|
Struct1ByteInt a0,
|
|
Struct1ByteInt a1,
|
|
Struct1ByteInt a2,
|
|
Struct1ByteInt a3,
|
|
Struct1ByteInt a4,
|
|
Struct1ByteInt a5,
|
|
Struct1ByteInt a6,
|
|
Struct1ByteInt a7,
|
|
Struct1ByteInt a8,
|
|
Struct1ByteInt a9) {
|
|
print(
|
|
"passStruct1ByteIntx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a1.a0;
|
|
result += a2.a0;
|
|
result += a3.a0;
|
|
result += a4.a0;
|
|
result += a5.a0;
|
|
result += a6.a0;
|
|
result += a7.a0;
|
|
result += a8.a0;
|
|
result += a9.a0;
|
|
|
|
print("result = $result");
|
|
PassStruct1ByteIntx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct1ByteIntx10AfterCallback() async {
|
|
final result = await PassStruct1ByteIntx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(5, result);
|
|
}
|
|
|
|
typedef PassStruct3BytesHomogeneousUint8x10Type = Void Function(
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8,
|
|
Struct3BytesHomogeneousUint8);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct3BytesHomogeneousUint8x10Result = Completer<double>();
|
|
|
|
/// Not a multiple of word size, not a power of two.
|
|
/// 10 struct arguments will exhaust available registers.
|
|
void passStruct3BytesHomogeneousUint8x10(
|
|
Struct3BytesHomogeneousUint8 a0,
|
|
Struct3BytesHomogeneousUint8 a1,
|
|
Struct3BytesHomogeneousUint8 a2,
|
|
Struct3BytesHomogeneousUint8 a3,
|
|
Struct3BytesHomogeneousUint8 a4,
|
|
Struct3BytesHomogeneousUint8 a5,
|
|
Struct3BytesHomogeneousUint8 a6,
|
|
Struct3BytesHomogeneousUint8 a7,
|
|
Struct3BytesHomogeneousUint8 a8,
|
|
Struct3BytesHomogeneousUint8 a9) {
|
|
print(
|
|
"passStruct3BytesHomogeneousUint8x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
|
|
print("result = $result");
|
|
PassStruct3BytesHomogeneousUint8x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct3BytesHomogeneousUint8x10AfterCallback() async {
|
|
final result = await PassStruct3BytesHomogeneousUint8x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(465, result);
|
|
}
|
|
|
|
typedef PassStruct3BytesInt2ByteAlignedx10Type = Void Function(
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned,
|
|
Struct3BytesInt2ByteAligned);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct3BytesInt2ByteAlignedx10Result = Completer<double>();
|
|
|
|
/// 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 passStruct3BytesInt2ByteAlignedx10(
|
|
Struct3BytesInt2ByteAligned a0,
|
|
Struct3BytesInt2ByteAligned a1,
|
|
Struct3BytesInt2ByteAligned a2,
|
|
Struct3BytesInt2ByteAligned a3,
|
|
Struct3BytesInt2ByteAligned a4,
|
|
Struct3BytesInt2ByteAligned a5,
|
|
Struct3BytesInt2ByteAligned a6,
|
|
Struct3BytesInt2ByteAligned a7,
|
|
Struct3BytesInt2ByteAligned a8,
|
|
Struct3BytesInt2ByteAligned a9) {
|
|
print(
|
|
"passStruct3BytesInt2ByteAlignedx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct3BytesInt2ByteAlignedx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct3BytesInt2ByteAlignedx10AfterCallback() async {
|
|
final result = await PassStruct3BytesInt2ByteAlignedx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct4BytesHomogeneousInt16x10Type = Void Function(
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct4BytesHomogeneousInt16);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct4BytesHomogeneousInt16x10Result = Completer<double>();
|
|
|
|
/// Exactly word size on 32-bit architectures.
|
|
/// 10 struct arguments will exhaust available registers.
|
|
void passStruct4BytesHomogeneousInt16x10(
|
|
Struct4BytesHomogeneousInt16 a0,
|
|
Struct4BytesHomogeneousInt16 a1,
|
|
Struct4BytesHomogeneousInt16 a2,
|
|
Struct4BytesHomogeneousInt16 a3,
|
|
Struct4BytesHomogeneousInt16 a4,
|
|
Struct4BytesHomogeneousInt16 a5,
|
|
Struct4BytesHomogeneousInt16 a6,
|
|
Struct4BytesHomogeneousInt16 a7,
|
|
Struct4BytesHomogeneousInt16 a8,
|
|
Struct4BytesHomogeneousInt16 a9) {
|
|
print(
|
|
"passStruct4BytesHomogeneousInt16x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct4BytesHomogeneousInt16x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct4BytesHomogeneousInt16x10AfterCallback() async {
|
|
final result = await PassStruct4BytesHomogeneousInt16x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct7BytesHomogeneousUint8x10Type = Void Function(
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8,
|
|
Struct7BytesHomogeneousUint8);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct7BytesHomogeneousUint8x10Result = Completer<double>();
|
|
|
|
/// Sub word size on 64 bit architectures.
|
|
/// 10 struct arguments will exhaust available registers.
|
|
void passStruct7BytesHomogeneousUint8x10(
|
|
Struct7BytesHomogeneousUint8 a0,
|
|
Struct7BytesHomogeneousUint8 a1,
|
|
Struct7BytesHomogeneousUint8 a2,
|
|
Struct7BytesHomogeneousUint8 a3,
|
|
Struct7BytesHomogeneousUint8 a4,
|
|
Struct7BytesHomogeneousUint8 a5,
|
|
Struct7BytesHomogeneousUint8 a6,
|
|
Struct7BytesHomogeneousUint8 a7,
|
|
Struct7BytesHomogeneousUint8 a8,
|
|
Struct7BytesHomogeneousUint8 a9) {
|
|
print(
|
|
"passStruct7BytesHomogeneousUint8x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
result += a0.a5;
|
|
result += a0.a6;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a1.a4;
|
|
result += a1.a5;
|
|
result += a1.a6;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a2.a4;
|
|
result += a2.a5;
|
|
result += a2.a6;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a3.a4;
|
|
result += a3.a5;
|
|
result += a3.a6;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
result += a4.a4;
|
|
result += a4.a5;
|
|
result += a4.a6;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a5.a4;
|
|
result += a5.a5;
|
|
result += a5.a6;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a6.a3;
|
|
result += a6.a4;
|
|
result += a6.a5;
|
|
result += a6.a6;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a7.a4;
|
|
result += a7.a5;
|
|
result += a7.a6;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a8.a3;
|
|
result += a8.a4;
|
|
result += a8.a5;
|
|
result += a8.a6;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
result += a9.a3;
|
|
result += a9.a4;
|
|
result += a9.a5;
|
|
result += a9.a6;
|
|
|
|
print("result = $result");
|
|
PassStruct7BytesHomogeneousUint8x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct7BytesHomogeneousUint8x10AfterCallback() async {
|
|
final result = await PassStruct7BytesHomogeneousUint8x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2485, result);
|
|
}
|
|
|
|
typedef PassStruct7BytesInt4ByteAlignedx10Type = Void Function(
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned,
|
|
Struct7BytesInt4ByteAligned);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct7BytesInt4ByteAlignedx10Result = Completer<double>();
|
|
|
|
/// 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 passStruct7BytesInt4ByteAlignedx10(
|
|
Struct7BytesInt4ByteAligned a0,
|
|
Struct7BytesInt4ByteAligned a1,
|
|
Struct7BytesInt4ByteAligned a2,
|
|
Struct7BytesInt4ByteAligned a3,
|
|
Struct7BytesInt4ByteAligned a4,
|
|
Struct7BytesInt4ByteAligned a5,
|
|
Struct7BytesInt4ByteAligned a6,
|
|
Struct7BytesInt4ByteAligned a7,
|
|
Struct7BytesInt4ByteAligned a8,
|
|
Struct7BytesInt4ByteAligned a9) {
|
|
print(
|
|
"passStruct7BytesInt4ByteAlignedx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
|
|
print("result = $result");
|
|
PassStruct7BytesInt4ByteAlignedx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct7BytesInt4ByteAlignedx10AfterCallback() async {
|
|
final result = await PassStruct7BytesInt4ByteAlignedx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(15, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesIntx10Type = Void Function(
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt,
|
|
Struct8BytesInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesIntx10Result = Completer<double>();
|
|
|
|
/// Exactly word size struct on 64bit architectures.
|
|
/// 10 struct arguments will exhaust available registers.
|
|
void passStruct8BytesIntx10(
|
|
Struct8BytesInt a0,
|
|
Struct8BytesInt a1,
|
|
Struct8BytesInt a2,
|
|
Struct8BytesInt a3,
|
|
Struct8BytesInt a4,
|
|
Struct8BytesInt a5,
|
|
Struct8BytesInt a6,
|
|
Struct8BytesInt a7,
|
|
Struct8BytesInt a8,
|
|
Struct8BytesInt a9) {
|
|
print(
|
|
"passStruct8BytesIntx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesIntx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesIntx10AfterCallback() async {
|
|
final result = await PassStruct8BytesIntx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(15, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesHomogeneousFloatx10Type = Void Function(
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat,
|
|
Struct8BytesHomogeneousFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesHomogeneousFloatx10Result = Completer<double>();
|
|
|
|
/// Arguments passed in FP registers as long as they fit.
|
|
/// 10 struct arguments will exhaust available registers.
|
|
void passStruct8BytesHomogeneousFloatx10(
|
|
Struct8BytesHomogeneousFloat a0,
|
|
Struct8BytesHomogeneousFloat a1,
|
|
Struct8BytesHomogeneousFloat a2,
|
|
Struct8BytesHomogeneousFloat a3,
|
|
Struct8BytesHomogeneousFloat a4,
|
|
Struct8BytesHomogeneousFloat a5,
|
|
Struct8BytesHomogeneousFloat a6,
|
|
Struct8BytesHomogeneousFloat a7,
|
|
Struct8BytesHomogeneousFloat a8,
|
|
Struct8BytesHomogeneousFloat a9) {
|
|
print(
|
|
"passStruct8BytesHomogeneousFloatx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesHomogeneousFloatx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesHomogeneousFloatx10AfterCallback() async {
|
|
final result = await PassStruct8BytesHomogeneousFloatx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesMixedx10Type = Void Function(
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed,
|
|
Struct8BytesMixed);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesMixedx10Result = Completer<double>();
|
|
|
|
/// On x64, arguments go in int registers because it is not only float.
|
|
/// 10 struct arguments will exhaust available registers.
|
|
void passStruct8BytesMixedx10(
|
|
Struct8BytesMixed a0,
|
|
Struct8BytesMixed a1,
|
|
Struct8BytesMixed a2,
|
|
Struct8BytesMixed a3,
|
|
Struct8BytesMixed a4,
|
|
Struct8BytesMixed a5,
|
|
Struct8BytesMixed a6,
|
|
Struct8BytesMixed a7,
|
|
Struct8BytesMixed a8,
|
|
Struct8BytesMixed a9) {
|
|
print(
|
|
"passStruct8BytesMixedx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesMixedx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesMixedx10AfterCallback() async {
|
|
final result = await PassStruct8BytesMixedx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(15, result);
|
|
}
|
|
|
|
typedef PassStruct9BytesHomogeneousUint8x10Type = Void Function(
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8,
|
|
Struct9BytesHomogeneousUint8);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct9BytesHomogeneousUint8x10Result = Completer<double>();
|
|
|
|
/// 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 passStruct9BytesHomogeneousUint8x10(
|
|
Struct9BytesHomogeneousUint8 a0,
|
|
Struct9BytesHomogeneousUint8 a1,
|
|
Struct9BytesHomogeneousUint8 a2,
|
|
Struct9BytesHomogeneousUint8 a3,
|
|
Struct9BytesHomogeneousUint8 a4,
|
|
Struct9BytesHomogeneousUint8 a5,
|
|
Struct9BytesHomogeneousUint8 a6,
|
|
Struct9BytesHomogeneousUint8 a7,
|
|
Struct9BytesHomogeneousUint8 a8,
|
|
Struct9BytesHomogeneousUint8 a9) {
|
|
print(
|
|
"passStruct9BytesHomogeneousUint8x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
result += a0.a5;
|
|
result += a0.a6;
|
|
result += a0.a7;
|
|
result += a0.a8;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a1.a4;
|
|
result += a1.a5;
|
|
result += a1.a6;
|
|
result += a1.a7;
|
|
result += a1.a8;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a2.a4;
|
|
result += a2.a5;
|
|
result += a2.a6;
|
|
result += a2.a7;
|
|
result += a2.a8;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a3.a4;
|
|
result += a3.a5;
|
|
result += a3.a6;
|
|
result += a3.a7;
|
|
result += a3.a8;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
result += a4.a4;
|
|
result += a4.a5;
|
|
result += a4.a6;
|
|
result += a4.a7;
|
|
result += a4.a8;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a5.a4;
|
|
result += a5.a5;
|
|
result += a5.a6;
|
|
result += a5.a7;
|
|
result += a5.a8;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a6.a3;
|
|
result += a6.a4;
|
|
result += a6.a5;
|
|
result += a6.a6;
|
|
result += a6.a7;
|
|
result += a6.a8;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a7.a4;
|
|
result += a7.a5;
|
|
result += a7.a6;
|
|
result += a7.a7;
|
|
result += a7.a8;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a8.a3;
|
|
result += a8.a4;
|
|
result += a8.a5;
|
|
result += a8.a6;
|
|
result += a8.a7;
|
|
result += a8.a8;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
result += a9.a3;
|
|
result += a9.a4;
|
|
result += a9.a5;
|
|
result += a9.a6;
|
|
result += a9.a7;
|
|
result += a9.a8;
|
|
|
|
print("result = $result");
|
|
PassStruct9BytesHomogeneousUint8x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct9BytesHomogeneousUint8x10AfterCallback() async {
|
|
final result = await PassStruct9BytesHomogeneousUint8x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(4095, result);
|
|
}
|
|
|
|
typedef PassStruct9BytesInt4Or8ByteAlignedx10Type = Void Function(
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned,
|
|
Struct9BytesInt4Or8ByteAligned);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct9BytesInt4Or8ByteAlignedx10Result = Completer<double>();
|
|
|
|
/// 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 passStruct9BytesInt4Or8ByteAlignedx10(
|
|
Struct9BytesInt4Or8ByteAligned a0,
|
|
Struct9BytesInt4Or8ByteAligned a1,
|
|
Struct9BytesInt4Or8ByteAligned a2,
|
|
Struct9BytesInt4Or8ByteAligned a3,
|
|
Struct9BytesInt4Or8ByteAligned a4,
|
|
Struct9BytesInt4Or8ByteAligned a5,
|
|
Struct9BytesInt4Or8ByteAligned a6,
|
|
Struct9BytesInt4Or8ByteAligned a7,
|
|
Struct9BytesInt4Or8ByteAligned a8,
|
|
Struct9BytesInt4Or8ByteAligned a9) {
|
|
print(
|
|
"passStruct9BytesInt4Or8ByteAlignedx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct9BytesInt4Or8ByteAlignedx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct9BytesInt4Or8ByteAlignedx10AfterCallback() async {
|
|
final result = await PassStruct9BytesInt4Or8ByteAlignedx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct12BytesHomogeneousFloatx6Type = Void Function(
|
|
Struct12BytesHomogeneousFloat,
|
|
Struct12BytesHomogeneousFloat,
|
|
Struct12BytesHomogeneousFloat,
|
|
Struct12BytesHomogeneousFloat,
|
|
Struct12BytesHomogeneousFloat,
|
|
Struct12BytesHomogeneousFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct12BytesHomogeneousFloatx6Result = Completer<double>();
|
|
|
|
/// 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 passStruct12BytesHomogeneousFloatx6(
|
|
Struct12BytesHomogeneousFloat a0,
|
|
Struct12BytesHomogeneousFloat a1,
|
|
Struct12BytesHomogeneousFloat a2,
|
|
Struct12BytesHomogeneousFloat a3,
|
|
Struct12BytesHomogeneousFloat a4,
|
|
Struct12BytesHomogeneousFloat a5) {
|
|
print(
|
|
"passStruct12BytesHomogeneousFloatx6(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
|
|
print("result = $result");
|
|
PassStruct12BytesHomogeneousFloatx6Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct12BytesHomogeneousFloatx6AfterCallback() async {
|
|
final result = await PassStruct12BytesHomogeneousFloatx6Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(9, result);
|
|
}
|
|
|
|
typedef PassStruct16BytesHomogeneousFloatx5Type = Void Function(
|
|
Struct16BytesHomogeneousFloat,
|
|
Struct16BytesHomogeneousFloat,
|
|
Struct16BytesHomogeneousFloat,
|
|
Struct16BytesHomogeneousFloat,
|
|
Struct16BytesHomogeneousFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct16BytesHomogeneousFloatx5Result = Completer<double>();
|
|
|
|
/// 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 passStruct16BytesHomogeneousFloatx5(
|
|
Struct16BytesHomogeneousFloat a0,
|
|
Struct16BytesHomogeneousFloat a1,
|
|
Struct16BytesHomogeneousFloat a2,
|
|
Struct16BytesHomogeneousFloat a3,
|
|
Struct16BytesHomogeneousFloat a4) {
|
|
print(
|
|
"passStruct16BytesHomogeneousFloatx5(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
|
|
print("result = $result");
|
|
PassStruct16BytesHomogeneousFloatx5Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct16BytesHomogeneousFloatx5AfterCallback() async {
|
|
final result = await PassStruct16BytesHomogeneousFloatx5Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct16BytesMixedx10Type = Void Function(
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct16BytesMixedx10Result = Completer<double>();
|
|
|
|
/// 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 passStruct16BytesMixedx10(
|
|
Struct16BytesMixed a0,
|
|
Struct16BytesMixed a1,
|
|
Struct16BytesMixed a2,
|
|
Struct16BytesMixed a3,
|
|
Struct16BytesMixed a4,
|
|
Struct16BytesMixed a5,
|
|
Struct16BytesMixed a6,
|
|
Struct16BytesMixed a7,
|
|
Struct16BytesMixed a8,
|
|
Struct16BytesMixed a9) {
|
|
print(
|
|
"passStruct16BytesMixedx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct16BytesMixedx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct16BytesMixedx10AfterCallback() async {
|
|
final result = await PassStruct16BytesMixedx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct16BytesMixed2x10Type = Void Function(
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2,
|
|
Struct16BytesMixed2);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct16BytesMixed2x10Result = Completer<double>();
|
|
|
|
/// 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 passStruct16BytesMixed2x10(
|
|
Struct16BytesMixed2 a0,
|
|
Struct16BytesMixed2 a1,
|
|
Struct16BytesMixed2 a2,
|
|
Struct16BytesMixed2 a3,
|
|
Struct16BytesMixed2 a4,
|
|
Struct16BytesMixed2 a5,
|
|
Struct16BytesMixed2 a6,
|
|
Struct16BytesMixed2 a7,
|
|
Struct16BytesMixed2 a8,
|
|
Struct16BytesMixed2 a9) {
|
|
print(
|
|
"passStruct16BytesMixed2x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a6.a3;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a8.a3;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
result += a9.a3;
|
|
|
|
print("result = $result");
|
|
PassStruct16BytesMixed2x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct16BytesMixed2x10AfterCallback() async {
|
|
final result = await PassStruct16BytesMixed2x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(20, result);
|
|
}
|
|
|
|
typedef PassStruct17BytesIntx10Type = Void Function(
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt,
|
|
Struct17BytesInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct17BytesIntx10Result = Completer<double>();
|
|
|
|
/// Arguments are passed as pointer to copy on arm64.
|
|
/// Tests that the memory allocated for copies are rounded up to word size.
|
|
void passStruct17BytesIntx10(
|
|
Struct17BytesInt a0,
|
|
Struct17BytesInt a1,
|
|
Struct17BytesInt a2,
|
|
Struct17BytesInt a3,
|
|
Struct17BytesInt a4,
|
|
Struct17BytesInt a5,
|
|
Struct17BytesInt a6,
|
|
Struct17BytesInt a7,
|
|
Struct17BytesInt a8,
|
|
Struct17BytesInt a9) {
|
|
print(
|
|
"passStruct17BytesIntx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
|
|
print("result = $result");
|
|
PassStruct17BytesIntx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct17BytesIntx10AfterCallback() async {
|
|
final result = await PassStruct17BytesIntx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(15, result);
|
|
}
|
|
|
|
typedef PassStruct19BytesHomogeneousUint8x10Type = Void Function(
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8,
|
|
Struct19BytesHomogeneousUint8);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct19BytesHomogeneousUint8x10Result = Completer<double>();
|
|
|
|
/// 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 passStruct19BytesHomogeneousUint8x10(
|
|
Struct19BytesHomogeneousUint8 a0,
|
|
Struct19BytesHomogeneousUint8 a1,
|
|
Struct19BytesHomogeneousUint8 a2,
|
|
Struct19BytesHomogeneousUint8 a3,
|
|
Struct19BytesHomogeneousUint8 a4,
|
|
Struct19BytesHomogeneousUint8 a5,
|
|
Struct19BytesHomogeneousUint8 a6,
|
|
Struct19BytesHomogeneousUint8 a7,
|
|
Struct19BytesHomogeneousUint8 a8,
|
|
Struct19BytesHomogeneousUint8 a9) {
|
|
print(
|
|
"passStruct19BytesHomogeneousUint8x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
result += a0.a5;
|
|
result += a0.a6;
|
|
result += a0.a7;
|
|
result += a0.a8;
|
|
result += a0.a9;
|
|
result += a0.a10;
|
|
result += a0.a11;
|
|
result += a0.a12;
|
|
result += a0.a13;
|
|
result += a0.a14;
|
|
result += a0.a15;
|
|
result += a0.a16;
|
|
result += a0.a17;
|
|
result += a0.a18;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a1.a4;
|
|
result += a1.a5;
|
|
result += a1.a6;
|
|
result += a1.a7;
|
|
result += a1.a8;
|
|
result += a1.a9;
|
|
result += a1.a10;
|
|
result += a1.a11;
|
|
result += a1.a12;
|
|
result += a1.a13;
|
|
result += a1.a14;
|
|
result += a1.a15;
|
|
result += a1.a16;
|
|
result += a1.a17;
|
|
result += a1.a18;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a2.a4;
|
|
result += a2.a5;
|
|
result += a2.a6;
|
|
result += a2.a7;
|
|
result += a2.a8;
|
|
result += a2.a9;
|
|
result += a2.a10;
|
|
result += a2.a11;
|
|
result += a2.a12;
|
|
result += a2.a13;
|
|
result += a2.a14;
|
|
result += a2.a15;
|
|
result += a2.a16;
|
|
result += a2.a17;
|
|
result += a2.a18;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a3.a4;
|
|
result += a3.a5;
|
|
result += a3.a6;
|
|
result += a3.a7;
|
|
result += a3.a8;
|
|
result += a3.a9;
|
|
result += a3.a10;
|
|
result += a3.a11;
|
|
result += a3.a12;
|
|
result += a3.a13;
|
|
result += a3.a14;
|
|
result += a3.a15;
|
|
result += a3.a16;
|
|
result += a3.a17;
|
|
result += a3.a18;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
result += a4.a4;
|
|
result += a4.a5;
|
|
result += a4.a6;
|
|
result += a4.a7;
|
|
result += a4.a8;
|
|
result += a4.a9;
|
|
result += a4.a10;
|
|
result += a4.a11;
|
|
result += a4.a12;
|
|
result += a4.a13;
|
|
result += a4.a14;
|
|
result += a4.a15;
|
|
result += a4.a16;
|
|
result += a4.a17;
|
|
result += a4.a18;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a5.a4;
|
|
result += a5.a5;
|
|
result += a5.a6;
|
|
result += a5.a7;
|
|
result += a5.a8;
|
|
result += a5.a9;
|
|
result += a5.a10;
|
|
result += a5.a11;
|
|
result += a5.a12;
|
|
result += a5.a13;
|
|
result += a5.a14;
|
|
result += a5.a15;
|
|
result += a5.a16;
|
|
result += a5.a17;
|
|
result += a5.a18;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a6.a3;
|
|
result += a6.a4;
|
|
result += a6.a5;
|
|
result += a6.a6;
|
|
result += a6.a7;
|
|
result += a6.a8;
|
|
result += a6.a9;
|
|
result += a6.a10;
|
|
result += a6.a11;
|
|
result += a6.a12;
|
|
result += a6.a13;
|
|
result += a6.a14;
|
|
result += a6.a15;
|
|
result += a6.a16;
|
|
result += a6.a17;
|
|
result += a6.a18;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a7.a4;
|
|
result += a7.a5;
|
|
result += a7.a6;
|
|
result += a7.a7;
|
|
result += a7.a8;
|
|
result += a7.a9;
|
|
result += a7.a10;
|
|
result += a7.a11;
|
|
result += a7.a12;
|
|
result += a7.a13;
|
|
result += a7.a14;
|
|
result += a7.a15;
|
|
result += a7.a16;
|
|
result += a7.a17;
|
|
result += a7.a18;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a8.a3;
|
|
result += a8.a4;
|
|
result += a8.a5;
|
|
result += a8.a6;
|
|
result += a8.a7;
|
|
result += a8.a8;
|
|
result += a8.a9;
|
|
result += a8.a10;
|
|
result += a8.a11;
|
|
result += a8.a12;
|
|
result += a8.a13;
|
|
result += a8.a14;
|
|
result += a8.a15;
|
|
result += a8.a16;
|
|
result += a8.a17;
|
|
result += a8.a18;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
result += a9.a3;
|
|
result += a9.a4;
|
|
result += a9.a5;
|
|
result += a9.a6;
|
|
result += a9.a7;
|
|
result += a9.a8;
|
|
result += a9.a9;
|
|
result += a9.a10;
|
|
result += a9.a11;
|
|
result += a9.a12;
|
|
result += a9.a13;
|
|
result += a9.a14;
|
|
result += a9.a15;
|
|
result += a9.a16;
|
|
result += a9.a17;
|
|
result += a9.a18;
|
|
|
|
print("result = $result");
|
|
PassStruct19BytesHomogeneousUint8x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct19BytesHomogeneousUint8x10AfterCallback() async {
|
|
final result = await PassStruct19BytesHomogeneousUint8x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(18145, result);
|
|
}
|
|
|
|
typedef PassStruct20BytesHomogeneousInt32x10Type = Void Function(
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32,
|
|
Struct20BytesHomogeneousInt32);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct20BytesHomogeneousInt32x10Result = Completer<double>();
|
|
|
|
/// 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 passStruct20BytesHomogeneousInt32x10(
|
|
Struct20BytesHomogeneousInt32 a0,
|
|
Struct20BytesHomogeneousInt32 a1,
|
|
Struct20BytesHomogeneousInt32 a2,
|
|
Struct20BytesHomogeneousInt32 a3,
|
|
Struct20BytesHomogeneousInt32 a4,
|
|
Struct20BytesHomogeneousInt32 a5,
|
|
Struct20BytesHomogeneousInt32 a6,
|
|
Struct20BytesHomogeneousInt32 a7,
|
|
Struct20BytesHomogeneousInt32 a8,
|
|
Struct20BytesHomogeneousInt32 a9) {
|
|
print(
|
|
"passStruct20BytesHomogeneousInt32x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a1.a4;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a2.a4;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a3.a4;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
result += a4.a4;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a5.a4;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a6.a3;
|
|
result += a6.a4;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a7.a4;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a8.a3;
|
|
result += a8.a4;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
result += a9.a3;
|
|
result += a9.a4;
|
|
|
|
print("result = $result");
|
|
PassStruct20BytesHomogeneousInt32x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct20BytesHomogeneousInt32x10AfterCallback() async {
|
|
final result = await PassStruct20BytesHomogeneousInt32x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(25, result);
|
|
}
|
|
|
|
typedef PassStruct20BytesHomogeneousFloatType = Void Function(
|
|
Struct20BytesHomogeneousFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct20BytesHomogeneousFloatResult = Completer<double>();
|
|
|
|
/// Argument too big to go into FPU registers in hardfp and arm64.
|
|
void passStruct20BytesHomogeneousFloat(Struct20BytesHomogeneousFloat a0) {
|
|
print("passStruct20BytesHomogeneousFloat(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
|
|
print("result = $result");
|
|
PassStruct20BytesHomogeneousFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct20BytesHomogeneousFloatAfterCallback() async {
|
|
final result = await PassStruct20BytesHomogeneousFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-3, result);
|
|
}
|
|
|
|
typedef PassStruct32BytesHomogeneousDoublex5Type = Void Function(
|
|
Struct32BytesHomogeneousDouble,
|
|
Struct32BytesHomogeneousDouble,
|
|
Struct32BytesHomogeneousDouble,
|
|
Struct32BytesHomogeneousDouble,
|
|
Struct32BytesHomogeneousDouble);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct32BytesHomogeneousDoublex5Result = Completer<double>();
|
|
|
|
/// Arguments in FPU registers on arm64.
|
|
/// 5 struct arguments will exhaust available registers.
|
|
void passStruct32BytesHomogeneousDoublex5(
|
|
Struct32BytesHomogeneousDouble a0,
|
|
Struct32BytesHomogeneousDouble a1,
|
|
Struct32BytesHomogeneousDouble a2,
|
|
Struct32BytesHomogeneousDouble a3,
|
|
Struct32BytesHomogeneousDouble a4) {
|
|
print(
|
|
"passStruct32BytesHomogeneousDoublex5(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
|
|
print("result = $result");
|
|
PassStruct32BytesHomogeneousDoublex5Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct32BytesHomogeneousDoublex5AfterCallback() async {
|
|
final result = await PassStruct32BytesHomogeneousDoublex5Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct40BytesHomogeneousDoubleType = Void Function(
|
|
Struct40BytesHomogeneousDouble);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct40BytesHomogeneousDoubleResult = Completer<double>();
|
|
|
|
/// Argument too big to go into FPU registers in arm64.
|
|
void passStruct40BytesHomogeneousDouble(Struct40BytesHomogeneousDouble a0) {
|
|
print("passStruct40BytesHomogeneousDouble(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
|
|
print("result = $result");
|
|
PassStruct40BytesHomogeneousDoubleResult.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct40BytesHomogeneousDoubleAfterCallback() async {
|
|
final result = await PassStruct40BytesHomogeneousDoubleResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-3, result);
|
|
}
|
|
|
|
typedef PassStruct1024BytesHomogeneousUint64Type = Void Function(
|
|
Struct1024BytesHomogeneousUint64);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct1024BytesHomogeneousUint64Result = Completer<double>();
|
|
|
|
/// Test 1kb struct.
|
|
void passStruct1024BytesHomogeneousUint64(Struct1024BytesHomogeneousUint64 a0) {
|
|
print("passStruct1024BytesHomogeneousUint64(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
result += a0.a5;
|
|
result += a0.a6;
|
|
result += a0.a7;
|
|
result += a0.a8;
|
|
result += a0.a9;
|
|
result += a0.a10;
|
|
result += a0.a11;
|
|
result += a0.a12;
|
|
result += a0.a13;
|
|
result += a0.a14;
|
|
result += a0.a15;
|
|
result += a0.a16;
|
|
result += a0.a17;
|
|
result += a0.a18;
|
|
result += a0.a19;
|
|
result += a0.a20;
|
|
result += a0.a21;
|
|
result += a0.a22;
|
|
result += a0.a23;
|
|
result += a0.a24;
|
|
result += a0.a25;
|
|
result += a0.a26;
|
|
result += a0.a27;
|
|
result += a0.a28;
|
|
result += a0.a29;
|
|
result += a0.a30;
|
|
result += a0.a31;
|
|
result += a0.a32;
|
|
result += a0.a33;
|
|
result += a0.a34;
|
|
result += a0.a35;
|
|
result += a0.a36;
|
|
result += a0.a37;
|
|
result += a0.a38;
|
|
result += a0.a39;
|
|
result += a0.a40;
|
|
result += a0.a41;
|
|
result += a0.a42;
|
|
result += a0.a43;
|
|
result += a0.a44;
|
|
result += a0.a45;
|
|
result += a0.a46;
|
|
result += a0.a47;
|
|
result += a0.a48;
|
|
result += a0.a49;
|
|
result += a0.a50;
|
|
result += a0.a51;
|
|
result += a0.a52;
|
|
result += a0.a53;
|
|
result += a0.a54;
|
|
result += a0.a55;
|
|
result += a0.a56;
|
|
result += a0.a57;
|
|
result += a0.a58;
|
|
result += a0.a59;
|
|
result += a0.a60;
|
|
result += a0.a61;
|
|
result += a0.a62;
|
|
result += a0.a63;
|
|
result += a0.a64;
|
|
result += a0.a65;
|
|
result += a0.a66;
|
|
result += a0.a67;
|
|
result += a0.a68;
|
|
result += a0.a69;
|
|
result += a0.a70;
|
|
result += a0.a71;
|
|
result += a0.a72;
|
|
result += a0.a73;
|
|
result += a0.a74;
|
|
result += a0.a75;
|
|
result += a0.a76;
|
|
result += a0.a77;
|
|
result += a0.a78;
|
|
result += a0.a79;
|
|
result += a0.a80;
|
|
result += a0.a81;
|
|
result += a0.a82;
|
|
result += a0.a83;
|
|
result += a0.a84;
|
|
result += a0.a85;
|
|
result += a0.a86;
|
|
result += a0.a87;
|
|
result += a0.a88;
|
|
result += a0.a89;
|
|
result += a0.a90;
|
|
result += a0.a91;
|
|
result += a0.a92;
|
|
result += a0.a93;
|
|
result += a0.a94;
|
|
result += a0.a95;
|
|
result += a0.a96;
|
|
result += a0.a97;
|
|
result += a0.a98;
|
|
result += a0.a99;
|
|
result += a0.a100;
|
|
result += a0.a101;
|
|
result += a0.a102;
|
|
result += a0.a103;
|
|
result += a0.a104;
|
|
result += a0.a105;
|
|
result += a0.a106;
|
|
result += a0.a107;
|
|
result += a0.a108;
|
|
result += a0.a109;
|
|
result += a0.a110;
|
|
result += a0.a111;
|
|
result += a0.a112;
|
|
result += a0.a113;
|
|
result += a0.a114;
|
|
result += a0.a115;
|
|
result += a0.a116;
|
|
result += a0.a117;
|
|
result += a0.a118;
|
|
result += a0.a119;
|
|
result += a0.a120;
|
|
result += a0.a121;
|
|
result += a0.a122;
|
|
result += a0.a123;
|
|
result += a0.a124;
|
|
result += a0.a125;
|
|
result += a0.a126;
|
|
result += a0.a127;
|
|
|
|
print("result = $result");
|
|
PassStruct1024BytesHomogeneousUint64Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct1024BytesHomogeneousUint64AfterCallback() async {
|
|
final result = await PassStruct1024BytesHomogeneousUint64Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(8256, result);
|
|
}
|
|
|
|
typedef PassFloatStruct16BytesHomogeneousFloatFloatStruct1Type = Void Function(
|
|
Float,
|
|
Struct16BytesHomogeneousFloat,
|
|
Float,
|
|
Struct16BytesHomogeneousFloat,
|
|
Float,
|
|
Struct16BytesHomogeneousFloat,
|
|
Float,
|
|
Struct16BytesHomogeneousFloat,
|
|
Float);
|
|
|
|
// Global variable that stores the result.
|
|
final PassFloatStruct16BytesHomogeneousFloatFloatStruct1Result =
|
|
Completer<double>();
|
|
|
|
/// Tests the alignment of structs in FPU registers and backfilling.
|
|
void passFloatStruct16BytesHomogeneousFloatFloatStruct1(
|
|
double a0,
|
|
Struct16BytesHomogeneousFloat a1,
|
|
double a2,
|
|
Struct16BytesHomogeneousFloat a3,
|
|
double a4,
|
|
Struct16BytesHomogeneousFloat a5,
|
|
double a6,
|
|
Struct16BytesHomogeneousFloat a7,
|
|
double a8) {
|
|
print(
|
|
"passFloatStruct16BytesHomogeneousFloatFloatStruct1(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a4;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a6;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a8;
|
|
|
|
print("result = $result");
|
|
PassFloatStruct16BytesHomogeneousFloatFloatStruct1Result.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passFloatStruct16BytesHomogeneousFloatFloatStruct1AfterCallback() async {
|
|
final result =
|
|
await PassFloatStruct16BytesHomogeneousFloatFloatStruct1Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-11, result);
|
|
}
|
|
|
|
typedef PassFloatStruct32BytesHomogeneousDoubleFloatStructType = Void Function(
|
|
Float,
|
|
Struct32BytesHomogeneousDouble,
|
|
Float,
|
|
Struct32BytesHomogeneousDouble,
|
|
Float,
|
|
Struct32BytesHomogeneousDouble,
|
|
Float,
|
|
Struct32BytesHomogeneousDouble,
|
|
Float);
|
|
|
|
// Global variable that stores the result.
|
|
final PassFloatStruct32BytesHomogeneousDoubleFloatStructResult =
|
|
Completer<double>();
|
|
|
|
/// Tests the alignment of structs in FPU registers and backfilling.
|
|
void passFloatStruct32BytesHomogeneousDoubleFloatStruct(
|
|
double a0,
|
|
Struct32BytesHomogeneousDouble a1,
|
|
double a2,
|
|
Struct32BytesHomogeneousDouble a3,
|
|
double a4,
|
|
Struct32BytesHomogeneousDouble a5,
|
|
double a6,
|
|
Struct32BytesHomogeneousDouble a7,
|
|
double a8) {
|
|
print(
|
|
"passFloatStruct32BytesHomogeneousDoubleFloatStruct(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a4;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a6;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a8;
|
|
|
|
print("result = $result");
|
|
PassFloatStruct32BytesHomogeneousDoubleFloatStructResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passFloatStruct32BytesHomogeneousDoubleFloatStructAfterCallback() async {
|
|
final result =
|
|
await PassFloatStruct32BytesHomogeneousDoubleFloatStructResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-11, result);
|
|
}
|
|
|
|
typedef PassInt8Struct16BytesMixedInt8Struct16BytesMixedInType = Void Function(
|
|
Int8,
|
|
Struct16BytesMixed,
|
|
Int8,
|
|
Struct16BytesMixed,
|
|
Int8,
|
|
Struct16BytesMixed,
|
|
Int8,
|
|
Struct16BytesMixed,
|
|
Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final PassInt8Struct16BytesMixedInt8Struct16BytesMixedInResult =
|
|
Completer<double>();
|
|
|
|
/// 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 passInt8Struct16BytesMixedInt8Struct16BytesMixedIn(
|
|
int a0,
|
|
Struct16BytesMixed a1,
|
|
int a2,
|
|
Struct16BytesMixed a3,
|
|
int a4,
|
|
Struct16BytesMixed a5,
|
|
int a6,
|
|
Struct16BytesMixed a7,
|
|
int a8) {
|
|
print(
|
|
"passInt8Struct16BytesMixedInt8Struct16BytesMixedIn(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8;
|
|
|
|
print("result = $result");
|
|
PassInt8Struct16BytesMixedInt8Struct16BytesMixedInResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passInt8Struct16BytesMixedInt8Struct16BytesMixedInAfterCallback() async {
|
|
final result =
|
|
await PassInt8Struct16BytesMixedInt8Struct16BytesMixedInResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-7, result);
|
|
}
|
|
|
|
typedef PassDoublex6Struct16BytesMixedx4Int32Type = Void Function(
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Double,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Int32);
|
|
|
|
// Global variable that stores the result.
|
|
final PassDoublex6Struct16BytesMixedx4Int32Result = Completer<double>();
|
|
|
|
/// 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 passDoublex6Struct16BytesMixedx4Int32(
|
|
double a0,
|
|
double a1,
|
|
double a2,
|
|
double a3,
|
|
double a4,
|
|
double a5,
|
|
Struct16BytesMixed a6,
|
|
Struct16BytesMixed a7,
|
|
Struct16BytesMixed a8,
|
|
Struct16BytesMixed a9,
|
|
int a10) {
|
|
print(
|
|
"passDoublex6Struct16BytesMixedx4Int32(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9}, ${a10})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a10;
|
|
|
|
print("result = $result");
|
|
PassDoublex6Struct16BytesMixedx4Int32Result.complete(result);
|
|
}
|
|
|
|
Future<void> passDoublex6Struct16BytesMixedx4Int32AfterCallback() async {
|
|
final result = await PassDoublex6Struct16BytesMixedx4Int32Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-8, result);
|
|
}
|
|
|
|
typedef PassInt32x4Struct16BytesMixedx4DoubleType = Void Function(
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Struct16BytesMixed,
|
|
Double);
|
|
|
|
// Global variable that stores the result.
|
|
final PassInt32x4Struct16BytesMixedx4DoubleResult = Completer<double>();
|
|
|
|
/// 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 passInt32x4Struct16BytesMixedx4Double(
|
|
int a0,
|
|
int a1,
|
|
int a2,
|
|
int a3,
|
|
Struct16BytesMixed a4,
|
|
Struct16BytesMixed a5,
|
|
Struct16BytesMixed a6,
|
|
Struct16BytesMixed a7,
|
|
double a8) {
|
|
print(
|
|
"passInt32x4Struct16BytesMixedx4Double(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8;
|
|
|
|
print("result = $result");
|
|
PassInt32x4Struct16BytesMixedx4DoubleResult.complete(result);
|
|
}
|
|
|
|
Future<void> passInt32x4Struct16BytesMixedx4DoubleAfterCallback() async {
|
|
final result = await PassInt32x4Struct16BytesMixedx4DoubleResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-7, result);
|
|
}
|
|
|
|
typedef PassStruct40BytesHomogeneousDoubleStruct4BytesHomoType = Void Function(
|
|
Struct40BytesHomogeneousDouble,
|
|
Struct4BytesHomogeneousInt16,
|
|
Struct8BytesHomogeneousFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct40BytesHomogeneousDoubleStruct4BytesHomoResult =
|
|
Completer<double>();
|
|
|
|
/// On various architectures, first struct is allocated on stack.
|
|
/// Check that the other two arguments are allocated on registers.
|
|
void passStruct40BytesHomogeneousDoubleStruct4BytesHomo(
|
|
Struct40BytesHomogeneousDouble a0,
|
|
Struct4BytesHomogeneousInt16 a1,
|
|
Struct8BytesHomogeneousFloat a2) {
|
|
print(
|
|
"passStruct40BytesHomogeneousDoubleStruct4BytesHomo(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct40BytesHomogeneousDoubleStruct4BytesHomoResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passStruct40BytesHomogeneousDoubleStruct4BytesHomoAfterCallback() async {
|
|
final result =
|
|
await PassStruct40BytesHomogeneousDoubleStruct4BytesHomoResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-5, result);
|
|
}
|
|
|
|
typedef PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntType = Void 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);
|
|
|
|
// Global variable that stores the result.
|
|
final PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntResult =
|
|
Completer<double>();
|
|
|
|
/// Test alignment and padding of 16 byte int within struct.
|
|
void passInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int(
|
|
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) {
|
|
print(
|
|
"passInt32x8Doublex8Int64Int8Struct1ByteIntInt64Int(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9}, ${a10}, ${a11}, ${a12}, ${a13}, ${a14}, ${a15}, ${a16}, ${a17}, ${a18}, ${a19}, ${a20}, ${a21}, ${a22}, ${a23}, ${a24}, ${a25}, ${a26}, ${a27}, ${a28}, ${a29}, ${a30}, ${a31}, ${a32}, ${a33}, ${a34}, ${a35}, ${a36}, ${a37}, ${a38}, ${a39})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6;
|
|
result += a7;
|
|
result += a8;
|
|
result += a9;
|
|
result += a10;
|
|
result += a11;
|
|
result += a12;
|
|
result += a13;
|
|
result += a14;
|
|
result += a15;
|
|
result += a16;
|
|
result += a17;
|
|
result += a18.a0;
|
|
result += a19;
|
|
result += a20;
|
|
result += a21.a0;
|
|
result += a21.a1;
|
|
result += a22;
|
|
result += a23;
|
|
result += a24.a0;
|
|
result += a24.a1;
|
|
result += a24.a2;
|
|
result += a25;
|
|
result += a26;
|
|
result += a27.a0;
|
|
result += a27.a1;
|
|
result += a28;
|
|
result += a29;
|
|
result += a30.a0;
|
|
result += a30.a1;
|
|
result += a30.a2;
|
|
result += a31;
|
|
result += a32;
|
|
result += a33.a0;
|
|
result += a33.a1;
|
|
result += a33.a2;
|
|
result += a34;
|
|
result += a35;
|
|
result += a36.a0;
|
|
result += a36.a1;
|
|
result += a36.a2;
|
|
result += a37;
|
|
result += a38;
|
|
result += a39.a0;
|
|
result += a39.a1;
|
|
result += a39.a2;
|
|
|
|
print("result = $result");
|
|
PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntAfterCallback() async {
|
|
final result =
|
|
await PassInt32x8Doublex8Int64Int8Struct1ByteIntInt64IntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(26, result);
|
|
}
|
|
|
|
typedef PassStructAlignmentInt16Type = Void Function(StructAlignmentInt16);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructAlignmentInt16Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of 16 byte int within struct.
|
|
void passStructAlignmentInt16(StructAlignmentInt16 a0) {
|
|
print("passStructAlignmentInt16(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
|
|
print("result = $result");
|
|
PassStructAlignmentInt16Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructAlignmentInt16AfterCallback() async {
|
|
final result = await PassStructAlignmentInt16Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef PassStructAlignmentInt32Type = Void Function(StructAlignmentInt32);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructAlignmentInt32Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of 32 byte int within struct.
|
|
void passStructAlignmentInt32(StructAlignmentInt32 a0) {
|
|
print("passStructAlignmentInt32(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
|
|
print("result = $result");
|
|
PassStructAlignmentInt32Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructAlignmentInt32AfterCallback() async {
|
|
final result = await PassStructAlignmentInt32Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef PassStructAlignmentInt64Type = Void Function(StructAlignmentInt64);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructAlignmentInt64Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of 64 byte int within struct.
|
|
void passStructAlignmentInt64(StructAlignmentInt64 a0) {
|
|
print("passStructAlignmentInt64(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
|
|
print("result = $result");
|
|
PassStructAlignmentInt64Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructAlignmentInt64AfterCallback() async {
|
|
final result = await PassStructAlignmentInt64Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesNestedIntx10Type = Void Function(
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt,
|
|
Struct8BytesNestedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesNestedIntx10Result = Completer<double>();
|
|
|
|
/// Simple nested struct. No alignment gaps on any architectures.
|
|
/// 10 arguments exhaust registers on all platforms.
|
|
void passStruct8BytesNestedIntx10(
|
|
Struct8BytesNestedInt a0,
|
|
Struct8BytesNestedInt a1,
|
|
Struct8BytesNestedInt a2,
|
|
Struct8BytesNestedInt a3,
|
|
Struct8BytesNestedInt a4,
|
|
Struct8BytesNestedInt a5,
|
|
Struct8BytesNestedInt a6,
|
|
Struct8BytesNestedInt a7,
|
|
Struct8BytesNestedInt a8,
|
|
Struct8BytesNestedInt a9) {
|
|
print(
|
|
"passStruct8BytesNestedIntx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a0.a1.a0;
|
|
result += a0.a1.a1;
|
|
result += a1.a0.a0;
|
|
result += a1.a0.a1;
|
|
result += a1.a1.a0;
|
|
result += a1.a1.a1;
|
|
result += a2.a0.a0;
|
|
result += a2.a0.a1;
|
|
result += a2.a1.a0;
|
|
result += a2.a1.a1;
|
|
result += a3.a0.a0;
|
|
result += a3.a0.a1;
|
|
result += a3.a1.a0;
|
|
result += a3.a1.a1;
|
|
result += a4.a0.a0;
|
|
result += a4.a0.a1;
|
|
result += a4.a1.a0;
|
|
result += a4.a1.a1;
|
|
result += a5.a0.a0;
|
|
result += a5.a0.a1;
|
|
result += a5.a1.a0;
|
|
result += a5.a1.a1;
|
|
result += a6.a0.a0;
|
|
result += a6.a0.a1;
|
|
result += a6.a1.a0;
|
|
result += a6.a1.a1;
|
|
result += a7.a0.a0;
|
|
result += a7.a0.a1;
|
|
result += a7.a1.a0;
|
|
result += a7.a1.a1;
|
|
result += a8.a0.a0;
|
|
result += a8.a0.a1;
|
|
result += a8.a1.a0;
|
|
result += a8.a1.a1;
|
|
result += a9.a0.a0;
|
|
result += a9.a0.a1;
|
|
result += a9.a1.a0;
|
|
result += a9.a1.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesNestedIntx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesNestedIntx10AfterCallback() async {
|
|
final result = await PassStruct8BytesNestedIntx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(20, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesNestedFloatx10Type = Void Function(
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat,
|
|
Struct8BytesNestedFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesNestedFloatx10Result = Completer<double>();
|
|
|
|
/// Simple nested struct. No alignment gaps on any architectures.
|
|
/// 10 arguments exhaust fpu registers on all platforms.
|
|
void passStruct8BytesNestedFloatx10(
|
|
Struct8BytesNestedFloat a0,
|
|
Struct8BytesNestedFloat a1,
|
|
Struct8BytesNestedFloat a2,
|
|
Struct8BytesNestedFloat a3,
|
|
Struct8BytesNestedFloat a4,
|
|
Struct8BytesNestedFloat a5,
|
|
Struct8BytesNestedFloat a6,
|
|
Struct8BytesNestedFloat a7,
|
|
Struct8BytesNestedFloat a8,
|
|
Struct8BytesNestedFloat a9) {
|
|
print(
|
|
"passStruct8BytesNestedFloatx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1.a0;
|
|
result += a1.a0.a0;
|
|
result += a1.a1.a0;
|
|
result += a2.a0.a0;
|
|
result += a2.a1.a0;
|
|
result += a3.a0.a0;
|
|
result += a3.a1.a0;
|
|
result += a4.a0.a0;
|
|
result += a4.a1.a0;
|
|
result += a5.a0.a0;
|
|
result += a5.a1.a0;
|
|
result += a6.a0.a0;
|
|
result += a6.a1.a0;
|
|
result += a7.a0.a0;
|
|
result += a7.a1.a0;
|
|
result += a8.a0.a0;
|
|
result += a8.a1.a0;
|
|
result += a9.a0.a0;
|
|
result += a9.a1.a0;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesNestedFloatx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesNestedFloatx10AfterCallback() async {
|
|
final result = await PassStruct8BytesNestedFloatx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesNestedFloat2x10Type = Void Function(
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2,
|
|
Struct8BytesNestedFloat2);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesNestedFloat2x10Result = Completer<double>();
|
|
|
|
/// Simple nested struct. No alignment gaps on any architectures.
|
|
/// 10 arguments exhaust fpu registers on all platforms.
|
|
/// The nesting is irregular, testing homogenous float rules on arm and arm64,
|
|
/// and the fpu register usage on x64.
|
|
void passStruct8BytesNestedFloat2x10(
|
|
Struct8BytesNestedFloat2 a0,
|
|
Struct8BytesNestedFloat2 a1,
|
|
Struct8BytesNestedFloat2 a2,
|
|
Struct8BytesNestedFloat2 a3,
|
|
Struct8BytesNestedFloat2 a4,
|
|
Struct8BytesNestedFloat2 a5,
|
|
Struct8BytesNestedFloat2 a6,
|
|
Struct8BytesNestedFloat2 a7,
|
|
Struct8BytesNestedFloat2 a8,
|
|
Struct8BytesNestedFloat2 a9) {
|
|
print(
|
|
"passStruct8BytesNestedFloat2x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0.a0;
|
|
result += a1.a1;
|
|
result += a2.a0.a0;
|
|
result += a2.a1;
|
|
result += a3.a0.a0;
|
|
result += a3.a1;
|
|
result += a4.a0.a0;
|
|
result += a4.a1;
|
|
result += a5.a0.a0;
|
|
result += a5.a1;
|
|
result += a6.a0.a0;
|
|
result += a6.a1;
|
|
result += a7.a0.a0;
|
|
result += a7.a1;
|
|
result += a8.a0.a0;
|
|
result += a8.a1;
|
|
result += a9.a0.a0;
|
|
result += a9.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesNestedFloat2x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesNestedFloat2x10AfterCallback() async {
|
|
final result = await PassStruct8BytesNestedFloat2x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesNestedMixedx10Type = Void Function(
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed,
|
|
Struct8BytesNestedMixed);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesNestedMixedx10Result = Completer<double>();
|
|
|
|
/// Simple nested struct. No alignment gaps on any architectures.
|
|
/// 10 arguments exhaust all registers on all platforms.
|
|
void passStruct8BytesNestedMixedx10(
|
|
Struct8BytesNestedMixed a0,
|
|
Struct8BytesNestedMixed a1,
|
|
Struct8BytesNestedMixed a2,
|
|
Struct8BytesNestedMixed a3,
|
|
Struct8BytesNestedMixed a4,
|
|
Struct8BytesNestedMixed a5,
|
|
Struct8BytesNestedMixed a6,
|
|
Struct8BytesNestedMixed a7,
|
|
Struct8BytesNestedMixed a8,
|
|
Struct8BytesNestedMixed a9) {
|
|
print(
|
|
"passStruct8BytesNestedMixedx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a0.a1.a0;
|
|
result += a1.a0.a0;
|
|
result += a1.a0.a1;
|
|
result += a1.a1.a0;
|
|
result += a2.a0.a0;
|
|
result += a2.a0.a1;
|
|
result += a2.a1.a0;
|
|
result += a3.a0.a0;
|
|
result += a3.a0.a1;
|
|
result += a3.a1.a0;
|
|
result += a4.a0.a0;
|
|
result += a4.a0.a1;
|
|
result += a4.a1.a0;
|
|
result += a5.a0.a0;
|
|
result += a5.a0.a1;
|
|
result += a5.a1.a0;
|
|
result += a6.a0.a0;
|
|
result += a6.a0.a1;
|
|
result += a6.a1.a0;
|
|
result += a7.a0.a0;
|
|
result += a7.a0.a1;
|
|
result += a7.a1.a0;
|
|
result += a8.a0.a0;
|
|
result += a8.a0.a1;
|
|
result += a8.a1.a0;
|
|
result += a9.a0.a0;
|
|
result += a9.a0.a1;
|
|
result += a9.a1.a0;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesNestedMixedx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesNestedMixedx10AfterCallback() async {
|
|
final result = await PassStruct8BytesNestedMixedx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(15, result);
|
|
}
|
|
|
|
typedef PassStruct16BytesNestedIntx2Type = Void Function(
|
|
Struct16BytesNestedInt, Struct16BytesNestedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct16BytesNestedIntx2Result = Completer<double>();
|
|
|
|
/// Deeper nested struct to test recursive member access.
|
|
void passStruct16BytesNestedIntx2(
|
|
Struct16BytesNestedInt a0, Struct16BytesNestedInt a1) {
|
|
print("passStruct16BytesNestedIntx2(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0.a0;
|
|
result += a0.a0.a0.a1;
|
|
result += a0.a0.a1.a0;
|
|
result += a0.a0.a1.a1;
|
|
result += a0.a1.a0.a0;
|
|
result += a0.a1.a0.a1;
|
|
result += a0.a1.a1.a0;
|
|
result += a0.a1.a1.a1;
|
|
result += a1.a0.a0.a0;
|
|
result += a1.a0.a0.a1;
|
|
result += a1.a0.a1.a0;
|
|
result += a1.a0.a1.a1;
|
|
result += a1.a1.a0.a0;
|
|
result += a1.a1.a0.a1;
|
|
result += a1.a1.a1.a0;
|
|
result += a1.a1.a1.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct16BytesNestedIntx2Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct16BytesNestedIntx2AfterCallback() async {
|
|
final result = await PassStruct16BytesNestedIntx2Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(8, result);
|
|
}
|
|
|
|
typedef PassStruct32BytesNestedIntx2Type = Void Function(
|
|
Struct32BytesNestedInt, Struct32BytesNestedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct32BytesNestedIntx2Result = Completer<double>();
|
|
|
|
/// Even deeper nested struct to test recursive member access.
|
|
void passStruct32BytesNestedIntx2(
|
|
Struct32BytesNestedInt a0, Struct32BytesNestedInt a1) {
|
|
print("passStruct32BytesNestedIntx2(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0.a0.a0;
|
|
result += a0.a0.a0.a0.a1;
|
|
result += a0.a0.a0.a1.a0;
|
|
result += a0.a0.a0.a1.a1;
|
|
result += a0.a0.a1.a0.a0;
|
|
result += a0.a0.a1.a0.a1;
|
|
result += a0.a0.a1.a1.a0;
|
|
result += a0.a0.a1.a1.a1;
|
|
result += a0.a1.a0.a0.a0;
|
|
result += a0.a1.a0.a0.a1;
|
|
result += a0.a1.a0.a1.a0;
|
|
result += a0.a1.a0.a1.a1;
|
|
result += a0.a1.a1.a0.a0;
|
|
result += a0.a1.a1.a0.a1;
|
|
result += a0.a1.a1.a1.a0;
|
|
result += a0.a1.a1.a1.a1;
|
|
result += a1.a0.a0.a0.a0;
|
|
result += a1.a0.a0.a0.a1;
|
|
result += a1.a0.a0.a1.a0;
|
|
result += a1.a0.a0.a1.a1;
|
|
result += a1.a0.a1.a0.a0;
|
|
result += a1.a0.a1.a0.a1;
|
|
result += a1.a0.a1.a1.a0;
|
|
result += a1.a0.a1.a1.a1;
|
|
result += a1.a1.a0.a0.a0;
|
|
result += a1.a1.a0.a0.a1;
|
|
result += a1.a1.a0.a1.a0;
|
|
result += a1.a1.a0.a1.a1;
|
|
result += a1.a1.a1.a0.a0;
|
|
result += a1.a1.a1.a0.a1;
|
|
result += a1.a1.a1.a1.a0;
|
|
result += a1.a1.a1.a1.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct32BytesNestedIntx2Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct32BytesNestedIntx2AfterCallback() async {
|
|
final result = await PassStruct32BytesNestedIntx2Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(16, result);
|
|
}
|
|
|
|
typedef PassStructNestedIntStructAlignmentInt16Type = Void Function(
|
|
StructNestedIntStructAlignmentInt16);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructNestedIntStructAlignmentInt16Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of nested struct with 16 byte int.
|
|
void passStructNestedIntStructAlignmentInt16(
|
|
StructNestedIntStructAlignmentInt16 a0) {
|
|
print("passStructNestedIntStructAlignmentInt16(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a0.a0.a2;
|
|
result += a0.a1.a0;
|
|
result += a0.a1.a1;
|
|
result += a0.a1.a2;
|
|
|
|
print("result = $result");
|
|
PassStructNestedIntStructAlignmentInt16Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructNestedIntStructAlignmentInt16AfterCallback() async {
|
|
final result = await PassStructNestedIntStructAlignmentInt16Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef PassStructNestedIntStructAlignmentInt32Type = Void Function(
|
|
StructNestedIntStructAlignmentInt32);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructNestedIntStructAlignmentInt32Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of nested struct with 32 byte int.
|
|
void passStructNestedIntStructAlignmentInt32(
|
|
StructNestedIntStructAlignmentInt32 a0) {
|
|
print("passStructNestedIntStructAlignmentInt32(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a0.a0.a2;
|
|
result += a0.a1.a0;
|
|
result += a0.a1.a1;
|
|
result += a0.a1.a2;
|
|
|
|
print("result = $result");
|
|
PassStructNestedIntStructAlignmentInt32Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructNestedIntStructAlignmentInt32AfterCallback() async {
|
|
final result = await PassStructNestedIntStructAlignmentInt32Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef PassStructNestedIntStructAlignmentInt64Type = Void Function(
|
|
StructNestedIntStructAlignmentInt64);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructNestedIntStructAlignmentInt64Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of nested struct with 64 byte int.
|
|
void passStructNestedIntStructAlignmentInt64(
|
|
StructNestedIntStructAlignmentInt64 a0) {
|
|
print("passStructNestedIntStructAlignmentInt64(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a0.a0.a2;
|
|
result += a0.a1.a0;
|
|
result += a0.a1.a1;
|
|
result += a0.a1.a2;
|
|
|
|
print("result = $result");
|
|
PassStructNestedIntStructAlignmentInt64Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructNestedIntStructAlignmentInt64AfterCallback() async {
|
|
final result = await PassStructNestedIntStructAlignmentInt64Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef PassStructNestedIrregularEvenBiggerx4Type = Void Function(
|
|
StructNestedIrregularEvenBigger,
|
|
StructNestedIrregularEvenBigger,
|
|
StructNestedIrregularEvenBigger,
|
|
StructNestedIrregularEvenBigger);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructNestedIrregularEvenBiggerx4Result = Completer<double>();
|
|
|
|
/// Return big irregular struct as smoke test.
|
|
void passStructNestedIrregularEvenBiggerx4(
|
|
StructNestedIrregularEvenBigger a0,
|
|
StructNestedIrregularEvenBigger a1,
|
|
StructNestedIrregularEvenBigger a2,
|
|
StructNestedIrregularEvenBigger a3) {
|
|
print("passStructNestedIrregularEvenBiggerx4(${a0}, ${a1}, ${a2}, ${a3})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1.a0.a0;
|
|
result += a0.a1.a0.a1.a0.a0;
|
|
result += a0.a1.a0.a1.a0.a1;
|
|
result += a0.a1.a0.a1.a1.a0;
|
|
result += a0.a1.a0.a2;
|
|
result += a0.a1.a0.a3.a0.a0;
|
|
result += a0.a1.a0.a3.a1;
|
|
result += a0.a1.a0.a4;
|
|
result += a0.a1.a0.a5.a0.a0;
|
|
result += a0.a1.a0.a5.a1.a0;
|
|
result += a0.a1.a0.a6;
|
|
result += a0.a1.a1.a0.a0;
|
|
result += a0.a1.a1.a0.a1;
|
|
result += a0.a1.a1.a1.a0;
|
|
result += a0.a1.a2;
|
|
result += a0.a1.a3;
|
|
result += a0.a2.a0.a0;
|
|
result += a0.a2.a0.a1.a0.a0;
|
|
result += a0.a2.a0.a1.a0.a1;
|
|
result += a0.a2.a0.a1.a1.a0;
|
|
result += a0.a2.a0.a2;
|
|
result += a0.a2.a0.a3.a0.a0;
|
|
result += a0.a2.a0.a3.a1;
|
|
result += a0.a2.a0.a4;
|
|
result += a0.a2.a0.a5.a0.a0;
|
|
result += a0.a2.a0.a5.a1.a0;
|
|
result += a0.a2.a0.a6;
|
|
result += a0.a2.a1.a0.a0;
|
|
result += a0.a2.a1.a0.a1;
|
|
result += a0.a2.a1.a1.a0;
|
|
result += a0.a2.a2;
|
|
result += a0.a2.a3;
|
|
result += a0.a3;
|
|
result += a1.a0;
|
|
result += a1.a1.a0.a0;
|
|
result += a1.a1.a0.a1.a0.a0;
|
|
result += a1.a1.a0.a1.a0.a1;
|
|
result += a1.a1.a0.a1.a1.a0;
|
|
result += a1.a1.a0.a2;
|
|
result += a1.a1.a0.a3.a0.a0;
|
|
result += a1.a1.a0.a3.a1;
|
|
result += a1.a1.a0.a4;
|
|
result += a1.a1.a0.a5.a0.a0;
|
|
result += a1.a1.a0.a5.a1.a0;
|
|
result += a1.a1.a0.a6;
|
|
result += a1.a1.a1.a0.a0;
|
|
result += a1.a1.a1.a0.a1;
|
|
result += a1.a1.a1.a1.a0;
|
|
result += a1.a1.a2;
|
|
result += a1.a1.a3;
|
|
result += a1.a2.a0.a0;
|
|
result += a1.a2.a0.a1.a0.a0;
|
|
result += a1.a2.a0.a1.a0.a1;
|
|
result += a1.a2.a0.a1.a1.a0;
|
|
result += a1.a2.a0.a2;
|
|
result += a1.a2.a0.a3.a0.a0;
|
|
result += a1.a2.a0.a3.a1;
|
|
result += a1.a2.a0.a4;
|
|
result += a1.a2.a0.a5.a0.a0;
|
|
result += a1.a2.a0.a5.a1.a0;
|
|
result += a1.a2.a0.a6;
|
|
result += a1.a2.a1.a0.a0;
|
|
result += a1.a2.a1.a0.a1;
|
|
result += a1.a2.a1.a1.a0;
|
|
result += a1.a2.a2;
|
|
result += a1.a2.a3;
|
|
result += a1.a3;
|
|
result += a2.a0;
|
|
result += a2.a1.a0.a0;
|
|
result += a2.a1.a0.a1.a0.a0;
|
|
result += a2.a1.a0.a1.a0.a1;
|
|
result += a2.a1.a0.a1.a1.a0;
|
|
result += a2.a1.a0.a2;
|
|
result += a2.a1.a0.a3.a0.a0;
|
|
result += a2.a1.a0.a3.a1;
|
|
result += a2.a1.a0.a4;
|
|
result += a2.a1.a0.a5.a0.a0;
|
|
result += a2.a1.a0.a5.a1.a0;
|
|
result += a2.a1.a0.a6;
|
|
result += a2.a1.a1.a0.a0;
|
|
result += a2.a1.a1.a0.a1;
|
|
result += a2.a1.a1.a1.a0;
|
|
result += a2.a1.a2;
|
|
result += a2.a1.a3;
|
|
result += a2.a2.a0.a0;
|
|
result += a2.a2.a0.a1.a0.a0;
|
|
result += a2.a2.a0.a1.a0.a1;
|
|
result += a2.a2.a0.a1.a1.a0;
|
|
result += a2.a2.a0.a2;
|
|
result += a2.a2.a0.a3.a0.a0;
|
|
result += a2.a2.a0.a3.a1;
|
|
result += a2.a2.a0.a4;
|
|
result += a2.a2.a0.a5.a0.a0;
|
|
result += a2.a2.a0.a5.a1.a0;
|
|
result += a2.a2.a0.a6;
|
|
result += a2.a2.a1.a0.a0;
|
|
result += a2.a2.a1.a0.a1;
|
|
result += a2.a2.a1.a1.a0;
|
|
result += a2.a2.a2;
|
|
result += a2.a2.a3;
|
|
result += a2.a3;
|
|
result += a3.a0;
|
|
result += a3.a1.a0.a0;
|
|
result += a3.a1.a0.a1.a0.a0;
|
|
result += a3.a1.a0.a1.a0.a1;
|
|
result += a3.a1.a0.a1.a1.a0;
|
|
result += a3.a1.a0.a2;
|
|
result += a3.a1.a0.a3.a0.a0;
|
|
result += a3.a1.a0.a3.a1;
|
|
result += a3.a1.a0.a4;
|
|
result += a3.a1.a0.a5.a0.a0;
|
|
result += a3.a1.a0.a5.a1.a0;
|
|
result += a3.a1.a0.a6;
|
|
result += a3.a1.a1.a0.a0;
|
|
result += a3.a1.a1.a0.a1;
|
|
result += a3.a1.a1.a1.a0;
|
|
result += a3.a1.a2;
|
|
result += a3.a1.a3;
|
|
result += a3.a2.a0.a0;
|
|
result += a3.a2.a0.a1.a0.a0;
|
|
result += a3.a2.a0.a1.a0.a1;
|
|
result += a3.a2.a0.a1.a1.a0;
|
|
result += a3.a2.a0.a2;
|
|
result += a3.a2.a0.a3.a0.a0;
|
|
result += a3.a2.a0.a3.a1;
|
|
result += a3.a2.a0.a4;
|
|
result += a3.a2.a0.a5.a0.a0;
|
|
result += a3.a2.a0.a5.a1.a0;
|
|
result += a3.a2.a0.a6;
|
|
result += a3.a2.a1.a0.a0;
|
|
result += a3.a2.a1.a0.a1;
|
|
result += a3.a2.a1.a1.a0;
|
|
result += a3.a2.a2;
|
|
result += a3.a2.a3;
|
|
result += a3.a3;
|
|
|
|
print("result = $result");
|
|
PassStructNestedIrregularEvenBiggerx4Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructNestedIrregularEvenBiggerx4AfterCallback() async {
|
|
final result = await PassStructNestedIrregularEvenBiggerx4Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1572, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesInlineArrayIntx4Type = Void Function(
|
|
Struct8BytesInlineArrayInt,
|
|
Struct8BytesInlineArrayInt,
|
|
Struct8BytesInlineArrayInt,
|
|
Struct8BytesInlineArrayInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesInlineArrayIntx4Result = Completer<double>();
|
|
|
|
/// Simple struct with inline array.
|
|
void passStruct8BytesInlineArrayIntx4(
|
|
Struct8BytesInlineArrayInt a0,
|
|
Struct8BytesInlineArrayInt a1,
|
|
Struct8BytesInlineArrayInt a2,
|
|
Struct8BytesInlineArrayInt a3) {
|
|
print("passStruct8BytesInlineArrayIntx4(${a0}, ${a1}, ${a2}, ${a3})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0[0];
|
|
result += a0.a0[1];
|
|
result += a0.a0[2];
|
|
result += a0.a0[3];
|
|
result += a0.a0[4];
|
|
result += a0.a0[5];
|
|
result += a0.a0[6];
|
|
result += a0.a0[7];
|
|
result += a1.a0[0];
|
|
result += a1.a0[1];
|
|
result += a1.a0[2];
|
|
result += a1.a0[3];
|
|
result += a1.a0[4];
|
|
result += a1.a0[5];
|
|
result += a1.a0[6];
|
|
result += a1.a0[7];
|
|
result += a2.a0[0];
|
|
result += a2.a0[1];
|
|
result += a2.a0[2];
|
|
result += a2.a0[3];
|
|
result += a2.a0[4];
|
|
result += a2.a0[5];
|
|
result += a2.a0[6];
|
|
result += a2.a0[7];
|
|
result += a3.a0[0];
|
|
result += a3.a0[1];
|
|
result += a3.a0[2];
|
|
result += a3.a0[3];
|
|
result += a3.a0[4];
|
|
result += a3.a0[5];
|
|
result += a3.a0[6];
|
|
result += a3.a0[7];
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesInlineArrayIntx4Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesInlineArrayIntx4AfterCallback() async {
|
|
final result = await PassStruct8BytesInlineArrayIntx4Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(528, result);
|
|
}
|
|
|
|
typedef PassStructInlineArrayIrregularx4Type = Void Function(
|
|
StructInlineArrayIrregular,
|
|
StructInlineArrayIrregular,
|
|
StructInlineArrayIrregular,
|
|
StructInlineArrayIrregular);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructInlineArrayIrregularx4Result = Completer<double>();
|
|
|
|
/// Irregular struct with inline array.
|
|
void passStructInlineArrayIrregularx4(
|
|
StructInlineArrayIrregular a0,
|
|
StructInlineArrayIrregular a1,
|
|
StructInlineArrayIrregular a2,
|
|
StructInlineArrayIrregular a3) {
|
|
print("passStructInlineArrayIrregularx4(${a0}, ${a1}, ${a2}, ${a3})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0[0].a0;
|
|
result += a0.a0[0].a1;
|
|
result += a0.a0[1].a0;
|
|
result += a0.a0[1].a1;
|
|
result += a0.a1;
|
|
result += a1.a0[0].a0;
|
|
result += a1.a0[0].a1;
|
|
result += a1.a0[1].a0;
|
|
result += a1.a0[1].a1;
|
|
result += a1.a1;
|
|
result += a2.a0[0].a0;
|
|
result += a2.a0[0].a1;
|
|
result += a2.a0[1].a0;
|
|
result += a2.a0[1].a1;
|
|
result += a2.a1;
|
|
result += a3.a0[0].a0;
|
|
result += a3.a0[0].a1;
|
|
result += a3.a0[1].a0;
|
|
result += a3.a0[1].a1;
|
|
result += a3.a1;
|
|
|
|
print("result = $result");
|
|
PassStructInlineArrayIrregularx4Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructInlineArrayIrregularx4AfterCallback() async {
|
|
final result = await PassStructInlineArrayIrregularx4Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(50, result);
|
|
}
|
|
|
|
typedef PassStructInlineArray100BytesType = Void Function(
|
|
StructInlineArray100Bytes);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructInlineArray100BytesResult = Completer<double>();
|
|
|
|
/// Regular larger struct with inline array.
|
|
void passStructInlineArray100Bytes(StructInlineArray100Bytes a0) {
|
|
print("passStructInlineArray100Bytes(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0[0];
|
|
result += a0.a0[1];
|
|
result += a0.a0[2];
|
|
result += a0.a0[3];
|
|
result += a0.a0[4];
|
|
result += a0.a0[5];
|
|
result += a0.a0[6];
|
|
result += a0.a0[7];
|
|
result += a0.a0[8];
|
|
result += a0.a0[9];
|
|
result += a0.a0[10];
|
|
result += a0.a0[11];
|
|
result += a0.a0[12];
|
|
result += a0.a0[13];
|
|
result += a0.a0[14];
|
|
result += a0.a0[15];
|
|
result += a0.a0[16];
|
|
result += a0.a0[17];
|
|
result += a0.a0[18];
|
|
result += a0.a0[19];
|
|
result += a0.a0[20];
|
|
result += a0.a0[21];
|
|
result += a0.a0[22];
|
|
result += a0.a0[23];
|
|
result += a0.a0[24];
|
|
result += a0.a0[25];
|
|
result += a0.a0[26];
|
|
result += a0.a0[27];
|
|
result += a0.a0[28];
|
|
result += a0.a0[29];
|
|
result += a0.a0[30];
|
|
result += a0.a0[31];
|
|
result += a0.a0[32];
|
|
result += a0.a0[33];
|
|
result += a0.a0[34];
|
|
result += a0.a0[35];
|
|
result += a0.a0[36];
|
|
result += a0.a0[37];
|
|
result += a0.a0[38];
|
|
result += a0.a0[39];
|
|
result += a0.a0[40];
|
|
result += a0.a0[41];
|
|
result += a0.a0[42];
|
|
result += a0.a0[43];
|
|
result += a0.a0[44];
|
|
result += a0.a0[45];
|
|
result += a0.a0[46];
|
|
result += a0.a0[47];
|
|
result += a0.a0[48];
|
|
result += a0.a0[49];
|
|
result += a0.a0[50];
|
|
result += a0.a0[51];
|
|
result += a0.a0[52];
|
|
result += a0.a0[53];
|
|
result += a0.a0[54];
|
|
result += a0.a0[55];
|
|
result += a0.a0[56];
|
|
result += a0.a0[57];
|
|
result += a0.a0[58];
|
|
result += a0.a0[59];
|
|
result += a0.a0[60];
|
|
result += a0.a0[61];
|
|
result += a0.a0[62];
|
|
result += a0.a0[63];
|
|
result += a0.a0[64];
|
|
result += a0.a0[65];
|
|
result += a0.a0[66];
|
|
result += a0.a0[67];
|
|
result += a0.a0[68];
|
|
result += a0.a0[69];
|
|
result += a0.a0[70];
|
|
result += a0.a0[71];
|
|
result += a0.a0[72];
|
|
result += a0.a0[73];
|
|
result += a0.a0[74];
|
|
result += a0.a0[75];
|
|
result += a0.a0[76];
|
|
result += a0.a0[77];
|
|
result += a0.a0[78];
|
|
result += a0.a0[79];
|
|
result += a0.a0[80];
|
|
result += a0.a0[81];
|
|
result += a0.a0[82];
|
|
result += a0.a0[83];
|
|
result += a0.a0[84];
|
|
result += a0.a0[85];
|
|
result += a0.a0[86];
|
|
result += a0.a0[87];
|
|
result += a0.a0[88];
|
|
result += a0.a0[89];
|
|
result += a0.a0[90];
|
|
result += a0.a0[91];
|
|
result += a0.a0[92];
|
|
result += a0.a0[93];
|
|
result += a0.a0[94];
|
|
result += a0.a0[95];
|
|
result += a0.a0[96];
|
|
result += a0.a0[97];
|
|
result += a0.a0[98];
|
|
result += a0.a0[99];
|
|
|
|
print("result = $result");
|
|
PassStructInlineArray100BytesResult.complete(result);
|
|
}
|
|
|
|
Future<void> passStructInlineArray100BytesAfterCallback() async {
|
|
final result = await PassStructInlineArray100BytesResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(5050, result);
|
|
}
|
|
|
|
typedef PassStructStruct16BytesHomogeneousFloat2x5Type = Void Function(
|
|
StructStruct16BytesHomogeneousFloat2,
|
|
StructStruct16BytesHomogeneousFloat2,
|
|
StructStruct16BytesHomogeneousFloat2,
|
|
StructStruct16BytesHomogeneousFloat2,
|
|
StructStruct16BytesHomogeneousFloat2);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructStruct16BytesHomogeneousFloat2x5Result = Completer<double>();
|
|
|
|
/// Arguments in FPU registers on arm hardfp and arm64.
|
|
/// 5 struct arguments will exhaust available registers.
|
|
void passStructStruct16BytesHomogeneousFloat2x5(
|
|
StructStruct16BytesHomogeneousFloat2 a0,
|
|
StructStruct16BytesHomogeneousFloat2 a1,
|
|
StructStruct16BytesHomogeneousFloat2 a2,
|
|
StructStruct16BytesHomogeneousFloat2 a3,
|
|
StructStruct16BytesHomogeneousFloat2 a4) {
|
|
print(
|
|
"passStructStruct16BytesHomogeneousFloat2x5(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1[0].a0;
|
|
result += a0.a1[1].a0;
|
|
result += a0.a2;
|
|
result += a1.a0.a0;
|
|
result += a1.a1[0].a0;
|
|
result += a1.a1[1].a0;
|
|
result += a1.a2;
|
|
result += a2.a0.a0;
|
|
result += a2.a1[0].a0;
|
|
result += a2.a1[1].a0;
|
|
result += a2.a2;
|
|
result += a3.a0.a0;
|
|
result += a3.a1[0].a0;
|
|
result += a3.a1[1].a0;
|
|
result += a3.a2;
|
|
result += a4.a0.a0;
|
|
result += a4.a1[0].a0;
|
|
result += a4.a1[1].a0;
|
|
result += a4.a2;
|
|
|
|
print("result = $result");
|
|
PassStructStruct16BytesHomogeneousFloat2x5Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructStruct16BytesHomogeneousFloat2x5AfterCallback() async {
|
|
final result = await PassStructStruct16BytesHomogeneousFloat2x5Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStructStruct32BytesHomogeneousDouble2x5Type = Void Function(
|
|
StructStruct32BytesHomogeneousDouble2,
|
|
StructStruct32BytesHomogeneousDouble2,
|
|
StructStruct32BytesHomogeneousDouble2,
|
|
StructStruct32BytesHomogeneousDouble2,
|
|
StructStruct32BytesHomogeneousDouble2);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructStruct32BytesHomogeneousDouble2x5Result = Completer<double>();
|
|
|
|
/// Arguments in FPU registers on arm64.
|
|
/// 5 struct arguments will exhaust available registers.
|
|
void passStructStruct32BytesHomogeneousDouble2x5(
|
|
StructStruct32BytesHomogeneousDouble2 a0,
|
|
StructStruct32BytesHomogeneousDouble2 a1,
|
|
StructStruct32BytesHomogeneousDouble2 a2,
|
|
StructStruct32BytesHomogeneousDouble2 a3,
|
|
StructStruct32BytesHomogeneousDouble2 a4) {
|
|
print(
|
|
"passStructStruct32BytesHomogeneousDouble2x5(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1[0].a0;
|
|
result += a0.a1[1].a0;
|
|
result += a0.a2;
|
|
result += a1.a0.a0;
|
|
result += a1.a1[0].a0;
|
|
result += a1.a1[1].a0;
|
|
result += a1.a2;
|
|
result += a2.a0.a0;
|
|
result += a2.a1[0].a0;
|
|
result += a2.a1[1].a0;
|
|
result += a2.a2;
|
|
result += a3.a0.a0;
|
|
result += a3.a1[0].a0;
|
|
result += a3.a1[1].a0;
|
|
result += a3.a2;
|
|
result += a4.a0.a0;
|
|
result += a4.a1[0].a0;
|
|
result += a4.a1[1].a0;
|
|
result += a4.a2;
|
|
|
|
print("result = $result");
|
|
PassStructStruct32BytesHomogeneousDouble2x5Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructStruct32BytesHomogeneousDouble2x5AfterCallback() async {
|
|
final result = await PassStructStruct32BytesHomogeneousDouble2x5Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStructStruct16BytesMixed3x10Type = Void Function(
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3,
|
|
StructStruct16BytesMixed3);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructStruct16BytesMixed3x10Result = Completer<double>();
|
|
|
|
/// 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 passStructStruct16BytesMixed3x10(
|
|
StructStruct16BytesMixed3 a0,
|
|
StructStruct16BytesMixed3 a1,
|
|
StructStruct16BytesMixed3 a2,
|
|
StructStruct16BytesMixed3 a3,
|
|
StructStruct16BytesMixed3 a4,
|
|
StructStruct16BytesMixed3 a5,
|
|
StructStruct16BytesMixed3 a6,
|
|
StructStruct16BytesMixed3 a7,
|
|
StructStruct16BytesMixed3 a8,
|
|
StructStruct16BytesMixed3 a9) {
|
|
print(
|
|
"passStructStruct16BytesMixed3x10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1[0].a0;
|
|
result += a0.a1[0].a1;
|
|
result += a0.a1[0].a2;
|
|
result += a0.a2[0];
|
|
result += a0.a2[1];
|
|
result += a1.a0.a0;
|
|
result += a1.a1[0].a0;
|
|
result += a1.a1[0].a1;
|
|
result += a1.a1[0].a2;
|
|
result += a1.a2[0];
|
|
result += a1.a2[1];
|
|
result += a2.a0.a0;
|
|
result += a2.a1[0].a0;
|
|
result += a2.a1[0].a1;
|
|
result += a2.a1[0].a2;
|
|
result += a2.a2[0];
|
|
result += a2.a2[1];
|
|
result += a3.a0.a0;
|
|
result += a3.a1[0].a0;
|
|
result += a3.a1[0].a1;
|
|
result += a3.a1[0].a2;
|
|
result += a3.a2[0];
|
|
result += a3.a2[1];
|
|
result += a4.a0.a0;
|
|
result += a4.a1[0].a0;
|
|
result += a4.a1[0].a1;
|
|
result += a4.a1[0].a2;
|
|
result += a4.a2[0];
|
|
result += a4.a2[1];
|
|
result += a5.a0.a0;
|
|
result += a5.a1[0].a0;
|
|
result += a5.a1[0].a1;
|
|
result += a5.a1[0].a2;
|
|
result += a5.a2[0];
|
|
result += a5.a2[1];
|
|
result += a6.a0.a0;
|
|
result += a6.a1[0].a0;
|
|
result += a6.a1[0].a1;
|
|
result += a6.a1[0].a2;
|
|
result += a6.a2[0];
|
|
result += a6.a2[1];
|
|
result += a7.a0.a0;
|
|
result += a7.a1[0].a0;
|
|
result += a7.a1[0].a1;
|
|
result += a7.a1[0].a2;
|
|
result += a7.a2[0];
|
|
result += a7.a2[1];
|
|
result += a8.a0.a0;
|
|
result += a8.a1[0].a0;
|
|
result += a8.a1[0].a1;
|
|
result += a8.a1[0].a2;
|
|
result += a8.a2[0];
|
|
result += a8.a2[1];
|
|
result += a9.a0.a0;
|
|
result += a9.a1[0].a0;
|
|
result += a9.a1[0].a1;
|
|
result += a9.a1[0].a2;
|
|
result += a9.a2[0];
|
|
result += a9.a2[1];
|
|
|
|
print("result = $result");
|
|
PassStructStruct16BytesMixed3x10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStructStruct16BytesMixed3x10AfterCallback() async {
|
|
final result = await PassStructStruct16BytesMixed3x10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(30, result);
|
|
}
|
|
|
|
typedef PassUint8Struct32BytesInlineArrayMultiDimensionalIType = Void Function(
|
|
Uint8,
|
|
Struct32BytesInlineArrayMultiDimensionalInt,
|
|
Uint8,
|
|
Struct8BytesInlineArrayMultiDimensionalInt,
|
|
Uint8,
|
|
Struct8BytesInlineArrayMultiDimensionalInt,
|
|
Uint8);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUint8Struct32BytesInlineArrayMultiDimensionalIResult =
|
|
Completer<double>();
|
|
|
|
/// Test multi dimensional inline array struct as argument.
|
|
void passUint8Struct32BytesInlineArrayMultiDimensionalI(
|
|
int a0,
|
|
Struct32BytesInlineArrayMultiDimensionalInt a1,
|
|
int a2,
|
|
Struct8BytesInlineArrayMultiDimensionalInt a3,
|
|
int a4,
|
|
Struct8BytesInlineArrayMultiDimensionalInt a5,
|
|
int a6) {
|
|
print(
|
|
"passUint8Struct32BytesInlineArrayMultiDimensionalI(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0[0][0][0][0][0];
|
|
result += a1.a0[0][0][0][0][1];
|
|
result += a1.a0[0][0][0][1][0];
|
|
result += a1.a0[0][0][0][1][1];
|
|
result += a1.a0[0][0][1][0][0];
|
|
result += a1.a0[0][0][1][0][1];
|
|
result += a1.a0[0][0][1][1][0];
|
|
result += a1.a0[0][0][1][1][1];
|
|
result += a1.a0[0][1][0][0][0];
|
|
result += a1.a0[0][1][0][0][1];
|
|
result += a1.a0[0][1][0][1][0];
|
|
result += a1.a0[0][1][0][1][1];
|
|
result += a1.a0[0][1][1][0][0];
|
|
result += a1.a0[0][1][1][0][1];
|
|
result += a1.a0[0][1][1][1][0];
|
|
result += a1.a0[0][1][1][1][1];
|
|
result += a1.a0[1][0][0][0][0];
|
|
result += a1.a0[1][0][0][0][1];
|
|
result += a1.a0[1][0][0][1][0];
|
|
result += a1.a0[1][0][0][1][1];
|
|
result += a1.a0[1][0][1][0][0];
|
|
result += a1.a0[1][0][1][0][1];
|
|
result += a1.a0[1][0][1][1][0];
|
|
result += a1.a0[1][0][1][1][1];
|
|
result += a1.a0[1][1][0][0][0];
|
|
result += a1.a0[1][1][0][0][1];
|
|
result += a1.a0[1][1][0][1][0];
|
|
result += a1.a0[1][1][0][1][1];
|
|
result += a1.a0[1][1][1][0][0];
|
|
result += a1.a0[1][1][1][0][1];
|
|
result += a1.a0[1][1][1][1][0];
|
|
result += a1.a0[1][1][1][1][1];
|
|
result += a2;
|
|
result += a3.a0[0][0][0];
|
|
result += a3.a0[0][0][1];
|
|
result += a3.a0[0][1][0];
|
|
result += a3.a0[0][1][1];
|
|
result += a3.a0[1][0][0];
|
|
result += a3.a0[1][0][1];
|
|
result += a3.a0[1][1][0];
|
|
result += a3.a0[1][1][1];
|
|
result += a4;
|
|
result += a5.a0[0][0][0];
|
|
result += a5.a0[0][0][1];
|
|
result += a5.a0[0][1][0];
|
|
result += a5.a0[0][1][1];
|
|
result += a5.a0[1][0][0];
|
|
result += a5.a0[1][0][1];
|
|
result += a5.a0[1][1][0];
|
|
result += a5.a0[1][1][1];
|
|
result += a6;
|
|
|
|
print("result = $result");
|
|
PassUint8Struct32BytesInlineArrayMultiDimensionalIResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passUint8Struct32BytesInlineArrayMultiDimensionalIAfterCallback() async {
|
|
final result =
|
|
await PassUint8Struct32BytesInlineArrayMultiDimensionalIResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1378, result);
|
|
}
|
|
|
|
typedef PassUint8Struct4BytesInlineArrayMultiDimensionalInType = Void Function(
|
|
Uint8, Struct4BytesInlineArrayMultiDimensionalInt, Uint8);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUint8Struct4BytesInlineArrayMultiDimensionalInResult =
|
|
Completer<double>();
|
|
|
|
/// Test struct in multi dimensional inline array.
|
|
void passUint8Struct4BytesInlineArrayMultiDimensionalIn(
|
|
int a0, Struct4BytesInlineArrayMultiDimensionalInt a1, int a2) {
|
|
print(
|
|
"passUint8Struct4BytesInlineArrayMultiDimensionalIn(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0[0][0].a0;
|
|
result += a1.a0[0][1].a0;
|
|
result += a1.a0[1][0].a0;
|
|
result += a1.a0[1][1].a0;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
PassUint8Struct4BytesInlineArrayMultiDimensionalInResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passUint8Struct4BytesInlineArrayMultiDimensionalInAfterCallback() async {
|
|
final result =
|
|
await PassUint8Struct4BytesInlineArrayMultiDimensionalInResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(5, result);
|
|
}
|
|
|
|
typedef PassStruct3BytesPackedIntx10Type = Void Function(
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt,
|
|
Struct3BytesPackedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct3BytesPackedIntx10Result = Completer<double>();
|
|
|
|
/// Small struct with mis-aligned member.
|
|
void passStruct3BytesPackedIntx10(
|
|
Struct3BytesPackedInt a0,
|
|
Struct3BytesPackedInt a1,
|
|
Struct3BytesPackedInt a2,
|
|
Struct3BytesPackedInt a3,
|
|
Struct3BytesPackedInt a4,
|
|
Struct3BytesPackedInt a5,
|
|
Struct3BytesPackedInt a6,
|
|
Struct3BytesPackedInt a7,
|
|
Struct3BytesPackedInt a8,
|
|
Struct3BytesPackedInt a9) {
|
|
print(
|
|
"passStruct3BytesPackedIntx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct3BytesPackedIntx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct3BytesPackedIntx10AfterCallback() async {
|
|
final result = await PassStruct3BytesPackedIntx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassStruct8BytesPackedIntx10Type = Void Function(
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt,
|
|
Struct8BytesPackedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct8BytesPackedIntx10Result = Completer<double>();
|
|
|
|
/// Struct with mis-aligned member.
|
|
void passStruct8BytesPackedIntx10(
|
|
Struct8BytesPackedInt a0,
|
|
Struct8BytesPackedInt a1,
|
|
Struct8BytesPackedInt a2,
|
|
Struct8BytesPackedInt a3,
|
|
Struct8BytesPackedInt a4,
|
|
Struct8BytesPackedInt a5,
|
|
Struct8BytesPackedInt a6,
|
|
Struct8BytesPackedInt a7,
|
|
Struct8BytesPackedInt a8,
|
|
Struct8BytesPackedInt a9) {
|
|
print(
|
|
"passStruct8BytesPackedIntx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a1.a4;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a2.a4;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a3.a2;
|
|
result += a3.a3;
|
|
result += a3.a4;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a4.a2;
|
|
result += a4.a3;
|
|
result += a4.a4;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a5.a2;
|
|
result += a5.a3;
|
|
result += a5.a4;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a6.a2;
|
|
result += a6.a3;
|
|
result += a6.a4;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a7.a2;
|
|
result += a7.a3;
|
|
result += a7.a4;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a8.a3;
|
|
result += a8.a4;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a9.a2;
|
|
result += a9.a3;
|
|
result += a9.a4;
|
|
|
|
print("result = $result");
|
|
PassStruct8BytesPackedIntx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct8BytesPackedIntx10AfterCallback() async {
|
|
final result = await PassStruct8BytesPackedIntx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1275, result);
|
|
}
|
|
|
|
typedef PassStruct9BytesPackedMixedx10DoubleInt32x2Type = Void Function(
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Struct9BytesPackedMixed,
|
|
Double,
|
|
Int32,
|
|
Int32);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct9BytesPackedMixedx10DoubleInt32x2Result = Completer<double>();
|
|
|
|
/// Struct with mis-aligned member.
|
|
/// Tests backfilling of CPU and FPU registers.
|
|
void passStruct9BytesPackedMixedx10DoubleInt32x2(
|
|
Struct9BytesPackedMixed a0,
|
|
Struct9BytesPackedMixed a1,
|
|
Struct9BytesPackedMixed a2,
|
|
Struct9BytesPackedMixed a3,
|
|
Struct9BytesPackedMixed a4,
|
|
Struct9BytesPackedMixed a5,
|
|
Struct9BytesPackedMixed a6,
|
|
Struct9BytesPackedMixed a7,
|
|
Struct9BytesPackedMixed a8,
|
|
Struct9BytesPackedMixed a9,
|
|
double a10,
|
|
int a11,
|
|
int a12) {
|
|
print(
|
|
"passStruct9BytesPackedMixedx10DoubleInt32x2(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9}, ${a10}, ${a11}, ${a12})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a2.a0;
|
|
result += a2.a1;
|
|
result += a3.a0;
|
|
result += a3.a1;
|
|
result += a4.a0;
|
|
result += a4.a1;
|
|
result += a5.a0;
|
|
result += a5.a1;
|
|
result += a6.a0;
|
|
result += a6.a1;
|
|
result += a7.a0;
|
|
result += a7.a1;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a9.a0;
|
|
result += a9.a1;
|
|
result += a10;
|
|
result += a11;
|
|
result += a12;
|
|
|
|
print("result = $result");
|
|
PassStruct9BytesPackedMixedx10DoubleInt32x2Result.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct9BytesPackedMixedx10DoubleInt32x2AfterCallback() async {
|
|
final result = await PassStruct9BytesPackedMixedx10DoubleInt32x2Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(188, result);
|
|
}
|
|
|
|
typedef PassStruct5BytesPackedMixedType = Void Function(
|
|
Struct5BytesPackedMixed);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct5BytesPackedMixedResult = Completer<double>();
|
|
|
|
/// This packed struct happens to have only aligned members.
|
|
void passStruct5BytesPackedMixed(Struct5BytesPackedMixed a0) {
|
|
print("passStruct5BytesPackedMixed(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
|
|
print("result = $result");
|
|
PassStruct5BytesPackedMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct5BytesPackedMixedAfterCallback() async {
|
|
final result = await PassStruct5BytesPackedMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef PassStructNestedAlignmentStruct5BytesPackedMixedType = Void Function(
|
|
StructNestedAlignmentStruct5BytesPackedMixed);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStructNestedAlignmentStruct5BytesPackedMixedResult =
|
|
Completer<double>();
|
|
|
|
/// Check alignment of packed struct in non-packed struct.
|
|
void passStructNestedAlignmentStruct5BytesPackedMixed(
|
|
StructNestedAlignmentStruct5BytesPackedMixed a0) {
|
|
print("passStructNestedAlignmentStruct5BytesPackedMixed(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1.a0;
|
|
result += a0.a1.a1;
|
|
|
|
print("result = $result");
|
|
PassStructNestedAlignmentStruct5BytesPackedMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passStructNestedAlignmentStruct5BytesPackedMixedAfterCallback() async {
|
|
final result =
|
|
await PassStructNestedAlignmentStruct5BytesPackedMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(6, result);
|
|
}
|
|
|
|
typedef PassStruct6BytesInlineArrayIntType = Void Function(
|
|
Struct6BytesInlineArrayInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct6BytesInlineArrayIntResult = Completer<double>();
|
|
|
|
/// Check alignment of packed struct array in non-packed struct.
|
|
void passStruct6BytesInlineArrayInt(Struct6BytesInlineArrayInt a0) {
|
|
print("passStruct6BytesInlineArrayInt(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0[0].a0;
|
|
result += a0.a0[0].a1;
|
|
result += a0.a0[1].a0;
|
|
result += a0.a0[1].a1;
|
|
|
|
print("result = $result");
|
|
PassStruct6BytesInlineArrayIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct6BytesInlineArrayIntAfterCallback() async {
|
|
final result = await PassStruct6BytesInlineArrayIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2, result);
|
|
}
|
|
|
|
typedef PassStruct15BytesInlineArrayMixedType = Void Function(
|
|
Struct15BytesInlineArrayMixed);
|
|
|
|
// Global variable that stores the result.
|
|
final PassStruct15BytesInlineArrayMixedResult = Completer<double>();
|
|
|
|
/// Check alignment of packed struct array in non-packed struct.
|
|
void passStruct15BytesInlineArrayMixed(Struct15BytesInlineArrayMixed a0) {
|
|
print("passStruct15BytesInlineArrayMixed(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0[0].a0;
|
|
result += a0.a0[0].a1;
|
|
result += a0.a0[1].a0;
|
|
result += a0.a0[1].a1;
|
|
result += a0.a0[2].a0;
|
|
result += a0.a0[2].a1;
|
|
|
|
print("result = $result");
|
|
PassStruct15BytesInlineArrayMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void> passStruct15BytesInlineArrayMixedAfterCallback() async {
|
|
final result = await PassStruct15BytesInlineArrayMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef PassUnion4BytesMixedx10Type = Void Function(
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed,
|
|
Union4BytesMixed);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUnion4BytesMixedx10Result = Completer<double>();
|
|
|
|
/// Check placement of mixed integer/float union.
|
|
void passUnion4BytesMixedx10(
|
|
Union4BytesMixed a0,
|
|
Union4BytesMixed a1,
|
|
Union4BytesMixed a2,
|
|
Union4BytesMixed a3,
|
|
Union4BytesMixed a4,
|
|
Union4BytesMixed a5,
|
|
Union4BytesMixed a6,
|
|
Union4BytesMixed a7,
|
|
Union4BytesMixed a8,
|
|
Union4BytesMixed a9) {
|
|
print(
|
|
"passUnion4BytesMixedx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a1.a0;
|
|
result += a2.a0;
|
|
result += a3.a0;
|
|
result += a4.a0;
|
|
result += a5.a0;
|
|
result += a6.a0;
|
|
result += a7.a0;
|
|
result += a8.a0;
|
|
result += a9.a0;
|
|
|
|
print("result = $result");
|
|
PassUnion4BytesMixedx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passUnion4BytesMixedx10AfterCallback() async {
|
|
final result = await PassUnion4BytesMixedx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(55, result);
|
|
}
|
|
|
|
typedef PassUnion8BytesNestedFloatx10Type = Void Function(
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat,
|
|
Union8BytesNestedFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUnion8BytesNestedFloatx10Result = Completer<double>();
|
|
|
|
/// Check placement of mixed floats union.
|
|
void passUnion8BytesNestedFloatx10(
|
|
Union8BytesNestedFloat a0,
|
|
Union8BytesNestedFloat a1,
|
|
Union8BytesNestedFloat a2,
|
|
Union8BytesNestedFloat a3,
|
|
Union8BytesNestedFloat a4,
|
|
Union8BytesNestedFloat a5,
|
|
Union8BytesNestedFloat a6,
|
|
Union8BytesNestedFloat a7,
|
|
Union8BytesNestedFloat a8,
|
|
Union8BytesNestedFloat a9) {
|
|
print(
|
|
"passUnion8BytesNestedFloatx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a1.a0;
|
|
result += a2.a0;
|
|
result += a3.a0;
|
|
result += a4.a0;
|
|
result += a5.a0;
|
|
result += a6.a0;
|
|
result += a7.a0;
|
|
result += a8.a0;
|
|
result += a9.a0;
|
|
|
|
print("result = $result");
|
|
PassUnion8BytesNestedFloatx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passUnion8BytesNestedFloatx10AfterCallback() async {
|
|
final result = await PassUnion8BytesNestedFloatx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(5, result);
|
|
}
|
|
|
|
typedef PassUnion9BytesNestedIntx10Type = Void Function(
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt,
|
|
Union9BytesNestedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUnion9BytesNestedIntx10Result = Completer<double>();
|
|
|
|
/// Mixed-size union argument.
|
|
void passUnion9BytesNestedIntx10(
|
|
Union9BytesNestedInt a0,
|
|
Union9BytesNestedInt a1,
|
|
Union9BytesNestedInt a2,
|
|
Union9BytesNestedInt a3,
|
|
Union9BytesNestedInt a4,
|
|
Union9BytesNestedInt a5,
|
|
Union9BytesNestedInt a6,
|
|
Union9BytesNestedInt a7,
|
|
Union9BytesNestedInt a8,
|
|
Union9BytesNestedInt a9) {
|
|
print(
|
|
"passUnion9BytesNestedIntx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a0.a0.a2;
|
|
result += a1.a0.a0;
|
|
result += a1.a0.a1;
|
|
result += a1.a0.a2;
|
|
result += a2.a0.a0;
|
|
result += a2.a0.a1;
|
|
result += a2.a0.a2;
|
|
result += a3.a0.a0;
|
|
result += a3.a0.a1;
|
|
result += a3.a0.a2;
|
|
result += a4.a0.a0;
|
|
result += a4.a0.a1;
|
|
result += a4.a0.a2;
|
|
result += a5.a0.a0;
|
|
result += a5.a0.a1;
|
|
result += a5.a0.a2;
|
|
result += a6.a0.a0;
|
|
result += a6.a0.a1;
|
|
result += a6.a0.a2;
|
|
result += a7.a0.a0;
|
|
result += a7.a0.a1;
|
|
result += a7.a0.a2;
|
|
result += a8.a0.a0;
|
|
result += a8.a0.a1;
|
|
result += a8.a0.a2;
|
|
result += a9.a0.a0;
|
|
result += a9.a0.a1;
|
|
result += a9.a0.a2;
|
|
|
|
print("result = $result");
|
|
PassUnion9BytesNestedIntx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passUnion9BytesNestedIntx10AfterCallback() async {
|
|
final result = await PassUnion9BytesNestedIntx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(15, result);
|
|
}
|
|
|
|
typedef PassUnion16BytesNestedInlineArrayFloatx10Type = Void Function(
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat,
|
|
Union16BytesNestedInlineArrayFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUnion16BytesNestedInlineArrayFloatx10Result = Completer<double>();
|
|
|
|
/// Union with homogenous floats.
|
|
void passUnion16BytesNestedInlineArrayFloatx10(
|
|
Union16BytesNestedInlineArrayFloat a0,
|
|
Union16BytesNestedInlineArrayFloat a1,
|
|
Union16BytesNestedInlineArrayFloat a2,
|
|
Union16BytesNestedInlineArrayFloat a3,
|
|
Union16BytesNestedInlineArrayFloat a4,
|
|
Union16BytesNestedInlineArrayFloat a5,
|
|
Union16BytesNestedInlineArrayFloat a6,
|
|
Union16BytesNestedInlineArrayFloat a7,
|
|
Union16BytesNestedInlineArrayFloat a8,
|
|
Union16BytesNestedInlineArrayFloat a9) {
|
|
print(
|
|
"passUnion16BytesNestedInlineArrayFloatx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0[0];
|
|
result += a0.a0[1];
|
|
result += a0.a0[2];
|
|
result += a0.a0[3];
|
|
result += a1.a0[0];
|
|
result += a1.a0[1];
|
|
result += a1.a0[2];
|
|
result += a1.a0[3];
|
|
result += a2.a0[0];
|
|
result += a2.a0[1];
|
|
result += a2.a0[2];
|
|
result += a2.a0[3];
|
|
result += a3.a0[0];
|
|
result += a3.a0[1];
|
|
result += a3.a0[2];
|
|
result += a3.a0[3];
|
|
result += a4.a0[0];
|
|
result += a4.a0[1];
|
|
result += a4.a0[2];
|
|
result += a4.a0[3];
|
|
result += a5.a0[0];
|
|
result += a5.a0[1];
|
|
result += a5.a0[2];
|
|
result += a5.a0[3];
|
|
result += a6.a0[0];
|
|
result += a6.a0[1];
|
|
result += a6.a0[2];
|
|
result += a6.a0[3];
|
|
result += a7.a0[0];
|
|
result += a7.a0[1];
|
|
result += a7.a0[2];
|
|
result += a7.a0[3];
|
|
result += a8.a0[0];
|
|
result += a8.a0[1];
|
|
result += a8.a0[2];
|
|
result += a8.a0[3];
|
|
result += a9.a0[0];
|
|
result += a9.a0[1];
|
|
result += a9.a0[2];
|
|
result += a9.a0[3];
|
|
|
|
print("result = $result");
|
|
PassUnion16BytesNestedInlineArrayFloatx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passUnion16BytesNestedInlineArrayFloatx10AfterCallback() async {
|
|
final result = await PassUnion16BytesNestedInlineArrayFloatx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(20, result);
|
|
}
|
|
|
|
typedef PassUnion16BytesNestedFloatx10Type = Void Function(
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat,
|
|
Union16BytesNestedFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUnion16BytesNestedFloatx10Result = Completer<double>();
|
|
|
|
/// Union with homogenous floats.
|
|
void passUnion16BytesNestedFloatx10(
|
|
Union16BytesNestedFloat a0,
|
|
Union16BytesNestedFloat a1,
|
|
Union16BytesNestedFloat a2,
|
|
Union16BytesNestedFloat a3,
|
|
Union16BytesNestedFloat a4,
|
|
Union16BytesNestedFloat a5,
|
|
Union16BytesNestedFloat a6,
|
|
Union16BytesNestedFloat a7,
|
|
Union16BytesNestedFloat a8,
|
|
Union16BytesNestedFloat a9) {
|
|
print(
|
|
"passUnion16BytesNestedFloatx10(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a1.a0.a0;
|
|
result += a1.a0.a1;
|
|
result += a2.a0.a0;
|
|
result += a2.a0.a1;
|
|
result += a3.a0.a0;
|
|
result += a3.a0.a1;
|
|
result += a4.a0.a0;
|
|
result += a4.a0.a1;
|
|
result += a5.a0.a0;
|
|
result += a5.a0.a1;
|
|
result += a6.a0.a0;
|
|
result += a6.a0.a1;
|
|
result += a7.a0.a0;
|
|
result += a7.a0.a1;
|
|
result += a8.a0.a0;
|
|
result += a8.a0.a1;
|
|
result += a9.a0.a0;
|
|
result += a9.a0.a1;
|
|
|
|
print("result = $result");
|
|
PassUnion16BytesNestedFloatx10Result.complete(result);
|
|
}
|
|
|
|
Future<void> passUnion16BytesNestedFloatx10AfterCallback() async {
|
|
final result = await PassUnion16BytesNestedFloatx10Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(10, result);
|
|
}
|
|
|
|
typedef PassUint8Boolx9Struct10BytesHomogeneousBoolBoolType = Void Function(
|
|
Uint8,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Struct10BytesHomogeneousBool,
|
|
Bool);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUint8Boolx9Struct10BytesHomogeneousBoolBoolResult =
|
|
Completer<double>();
|
|
|
|
/// Passing bools and a struct with bools.
|
|
/// Exhausts the registers to test bools and the bool struct alignment on the
|
|
/// stack.
|
|
void passUint8Boolx9Struct10BytesHomogeneousBoolBool(
|
|
int a0,
|
|
bool a1,
|
|
bool a2,
|
|
bool a3,
|
|
bool a4,
|
|
bool a5,
|
|
bool a6,
|
|
bool a7,
|
|
bool a8,
|
|
bool a9,
|
|
Struct10BytesHomogeneousBool a10,
|
|
bool a11) {
|
|
print(
|
|
"passUint8Boolx9Struct10BytesHomogeneousBoolBool(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9}, ${a10}, ${a11})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1 ? 1 : 0;
|
|
result += a2 ? 1 : 0;
|
|
result += a3 ? 1 : 0;
|
|
result += a4 ? 1 : 0;
|
|
result += a5 ? 1 : 0;
|
|
result += a6 ? 1 : 0;
|
|
result += a7 ? 1 : 0;
|
|
result += a8 ? 1 : 0;
|
|
result += a9 ? 1 : 0;
|
|
result += a10.a0 ? 1 : 0;
|
|
result += a10.a1 ? 1 : 0;
|
|
result += a10.a2 ? 1 : 0;
|
|
result += a10.a3 ? 1 : 0;
|
|
result += a10.a4 ? 1 : 0;
|
|
result += a10.a5 ? 1 : 0;
|
|
result += a10.a6 ? 1 : 0;
|
|
result += a10.a7 ? 1 : 0;
|
|
result += a10.a8 ? 1 : 0;
|
|
result += a10.a9 ? 1 : 0;
|
|
result += a11 ? 1 : 0;
|
|
|
|
print("result = $result");
|
|
PassUint8Boolx9Struct10BytesHomogeneousBoolBoolResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passUint8Boolx9Struct10BytesHomogeneousBoolBoolAfterCallback() async {
|
|
final result =
|
|
await PassUint8Boolx9Struct10BytesHomogeneousBoolBoolResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(11, result);
|
|
}
|
|
|
|
typedef PassUint8Boolx9Struct10BytesInlineArrayBoolBoolType = Void Function(
|
|
Uint8,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Bool,
|
|
Struct10BytesInlineArrayBool,
|
|
Bool);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUint8Boolx9Struct10BytesInlineArrayBoolBoolResult =
|
|
Completer<double>();
|
|
|
|
/// Passing bools and a struct with bools.
|
|
/// Exhausts the registers to test bools and the bool struct alignment on the
|
|
/// stack.
|
|
void passUint8Boolx9Struct10BytesInlineArrayBoolBool(
|
|
int a0,
|
|
bool a1,
|
|
bool a2,
|
|
bool a3,
|
|
bool a4,
|
|
bool a5,
|
|
bool a6,
|
|
bool a7,
|
|
bool a8,
|
|
bool a9,
|
|
Struct10BytesInlineArrayBool a10,
|
|
bool a11) {
|
|
print(
|
|
"passUint8Boolx9Struct10BytesInlineArrayBoolBool(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9}, ${a10}, ${a11})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1 ? 1 : 0;
|
|
result += a2 ? 1 : 0;
|
|
result += a3 ? 1 : 0;
|
|
result += a4 ? 1 : 0;
|
|
result += a5 ? 1 : 0;
|
|
result += a6 ? 1 : 0;
|
|
result += a7 ? 1 : 0;
|
|
result += a8 ? 1 : 0;
|
|
result += a9 ? 1 : 0;
|
|
result += a10.a0[0] ? 1 : 0;
|
|
result += a10.a0[1] ? 1 : 0;
|
|
result += a10.a0[2] ? 1 : 0;
|
|
result += a10.a0[3] ? 1 : 0;
|
|
result += a10.a0[4] ? 1 : 0;
|
|
result += a10.a0[5] ? 1 : 0;
|
|
result += a10.a0[6] ? 1 : 0;
|
|
result += a10.a0[7] ? 1 : 0;
|
|
result += a10.a0[8] ? 1 : 0;
|
|
result += a10.a0[9] ? 1 : 0;
|
|
result += a11 ? 1 : 0;
|
|
|
|
print("result = $result");
|
|
PassUint8Boolx9Struct10BytesInlineArrayBoolBoolResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passUint8Boolx9Struct10BytesInlineArrayBoolBoolAfterCallback() async {
|
|
final result =
|
|
await PassUint8Boolx9Struct10BytesInlineArrayBoolBoolResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(11, result);
|
|
}
|
|
|
|
typedef PassUint8Struct1ByteBoolType = Void Function(Uint8, Struct1ByteBool);
|
|
|
|
// Global variable that stores the result.
|
|
final PassUint8Struct1ByteBoolResult = Completer<double>();
|
|
|
|
/// Returning a bool.
|
|
void passUint8Struct1ByteBool(int a0, Struct1ByteBool a1) {
|
|
print("passUint8Struct1ByteBool(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0 ? 1 : 0;
|
|
|
|
print("result = $result");
|
|
PassUint8Struct1ByteBoolResult.complete(result);
|
|
}
|
|
|
|
Future<void> passUint8Struct1ByteBoolAfterCallback() async {
|
|
final result = await PassUint8Struct1ByteBoolResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef PassWCharStructInlineArrayIntUintPtrx2LongUnsignedType = Void Function(
|
|
WChar, StructInlineArrayInt, UintPtr, UintPtr, Long, UnsignedLong);
|
|
|
|
// Global variable that stores the result.
|
|
final PassWCharStructInlineArrayIntUintPtrx2LongUnsignedResult =
|
|
Completer<double>();
|
|
|
|
/// Returning a wchar.
|
|
void passWCharStructInlineArrayIntUintPtrx2LongUnsigned(
|
|
int a0, StructInlineArrayInt a1, int a2, int a3, int a4, int a5) {
|
|
print(
|
|
"passWCharStructInlineArrayIntUintPtrx2LongUnsigned(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0[0];
|
|
result += a1.a0[1];
|
|
result += a1.a0[2];
|
|
result += a1.a0[3];
|
|
result += a1.a0[4];
|
|
result += a1.a0[5];
|
|
result += a1.a0[6];
|
|
result += a1.a0[7];
|
|
result += a1.a0[8];
|
|
result += a1.a0[9];
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
|
|
print("result = $result");
|
|
PassWCharStructInlineArrayIntUintPtrx2LongUnsignedResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
passWCharStructInlineArrayIntUintPtrx2LongUnsignedAfterCallback() async {
|
|
final result =
|
|
await PassWCharStructInlineArrayIntUintPtrx2LongUnsignedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(120, result);
|
|
}
|
|
|
|
typedef ReturnStruct1ByteIntType = Void Function(Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct1ByteIntResult = Completer<double>();
|
|
|
|
/// Smallest struct with data.
|
|
void returnStruct1ByteInt(int a0) {
|
|
print("returnStruct1ByteInt(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
|
|
print("result = $result");
|
|
ReturnStruct1ByteIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct1ByteIntAfterCallback() async {
|
|
final result = await ReturnStruct1ByteIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-1, result);
|
|
}
|
|
|
|
typedef ReturnStruct3BytesHomogeneousUint8Type = Void Function(
|
|
Uint8, Uint8, Uint8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct3BytesHomogeneousUint8Result = Completer<double>();
|
|
|
|
/// Smaller than word size return value on all architectures.
|
|
void returnStruct3BytesHomogeneousUint8(int a0, int a1, int a2) {
|
|
print("returnStruct3BytesHomogeneousUint8(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStruct3BytesHomogeneousUint8Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct3BytesHomogeneousUint8AfterCallback() async {
|
|
final result = await ReturnStruct3BytesHomogeneousUint8Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(6, result);
|
|
}
|
|
|
|
typedef ReturnStruct3BytesInt2ByteAlignedType = Void Function(Int16, Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct3BytesInt2ByteAlignedResult = Completer<double>();
|
|
|
|
/// Smaller than word size return value on all architectures.
|
|
/// With alignment rules taken into account size is 4 bytes.
|
|
void returnStruct3BytesInt2ByteAligned(int a0, int a1) {
|
|
print("returnStruct3BytesInt2ByteAligned(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct3BytesInt2ByteAlignedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct3BytesInt2ByteAlignedAfterCallback() async {
|
|
final result = await ReturnStruct3BytesInt2ByteAlignedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct4BytesHomogeneousInt16Type = Void Function(Int16, Int16);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct4BytesHomogeneousInt16Result = Completer<double>();
|
|
|
|
/// Word size return value on 32 bit architectures..
|
|
void returnStruct4BytesHomogeneousInt16(int a0, int a1) {
|
|
print("returnStruct4BytesHomogeneousInt16(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct4BytesHomogeneousInt16Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct4BytesHomogeneousInt16AfterCallback() async {
|
|
final result = await ReturnStruct4BytesHomogeneousInt16Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct7BytesHomogeneousUint8Type = Void Function(
|
|
Uint8, Uint8, Uint8, Uint8, Uint8, Uint8, Uint8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct7BytesHomogeneousUint8Result = Completer<double>();
|
|
|
|
/// Non-wordsize return value.
|
|
void returnStruct7BytesHomogeneousUint8(
|
|
int a0, int a1, int a2, int a3, int a4, int a5, int a6) {
|
|
print(
|
|
"returnStruct7BytesHomogeneousUint8(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6;
|
|
|
|
print("result = $result");
|
|
ReturnStruct7BytesHomogeneousUint8Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct7BytesHomogeneousUint8AfterCallback() async {
|
|
final result = await ReturnStruct7BytesHomogeneousUint8Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(28, result);
|
|
}
|
|
|
|
typedef ReturnStruct7BytesInt4ByteAlignedType = Void Function(
|
|
Int32, Int16, Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct7BytesInt4ByteAlignedResult = Completer<double>();
|
|
|
|
/// Non-wordsize return value.
|
|
/// With alignment rules taken into account size is 8 bytes.
|
|
void returnStruct7BytesInt4ByteAligned(int a0, int a1, int a2) {
|
|
print("returnStruct7BytesInt4ByteAligned(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStruct7BytesInt4ByteAlignedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct7BytesInt4ByteAlignedAfterCallback() async {
|
|
final result = await ReturnStruct7BytesInt4ByteAlignedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesIntType = Void Function(Int16, Int16, Int32);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesIntResult = Completer<double>();
|
|
|
|
/// Return value in integer registers on many architectures.
|
|
void returnStruct8BytesInt(int a0, int a1, int a2) {
|
|
print("returnStruct8BytesInt(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesIntAfterCallback() async {
|
|
final result = await ReturnStruct8BytesIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesHomogeneousFloatType = Void Function(Float, Float);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesHomogeneousFloatResult = Completer<double>();
|
|
|
|
/// Return value in FP registers on many architectures.
|
|
void returnStruct8BytesHomogeneousFloat(double a0, double a1) {
|
|
print("returnStruct8BytesHomogeneousFloat(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesHomogeneousFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesHomogeneousFloatAfterCallback() async {
|
|
final result = await ReturnStruct8BytesHomogeneousFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesMixedType = Void Function(Float, Int16, Int16);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesMixedResult = Completer<double>();
|
|
|
|
/// Return value split over FP and integer register in x64.
|
|
void returnStruct8BytesMixed(double a0, int a1, int a2) {
|
|
print("returnStruct8BytesMixed(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesMixedAfterCallback() async {
|
|
final result = await ReturnStruct8BytesMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStruct9BytesHomogeneousUint8Type = Void Function(
|
|
Uint8, Uint8, Uint8, Uint8, Uint8, Uint8, Uint8, Uint8, Uint8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct9BytesHomogeneousUint8Result = Completer<double>();
|
|
|
|
/// The minimum alignment of this struct is only 1 byte based on its fields.
|
|
/// Test that the memory backing these structs is the right size and that
|
|
/// dart:ffi trampolines do not write outside this size.
|
|
void returnStruct9BytesHomogeneousUint8(
|
|
int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) {
|
|
print(
|
|
"returnStruct9BytesHomogeneousUint8(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6;
|
|
result += a7;
|
|
result += a8;
|
|
|
|
print("result = $result");
|
|
ReturnStruct9BytesHomogeneousUint8Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct9BytesHomogeneousUint8AfterCallback() async {
|
|
final result = await ReturnStruct9BytesHomogeneousUint8Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(45, result);
|
|
}
|
|
|
|
typedef ReturnStruct9BytesInt4Or8ByteAlignedType = Void Function(Int64, Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct9BytesInt4Or8ByteAlignedResult = Completer<double>();
|
|
|
|
/// Return value in two integer registers on x64.
|
|
/// With alignment rules taken into account size is 12 or 16 bytes.
|
|
void returnStruct9BytesInt4Or8ByteAligned(int a0, int a1) {
|
|
print("returnStruct9BytesInt4Or8ByteAligned(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct9BytesInt4Or8ByteAlignedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct9BytesInt4Or8ByteAlignedAfterCallback() async {
|
|
final result = await ReturnStruct9BytesInt4Or8ByteAlignedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct12BytesHomogeneousFloatType = Void Function(
|
|
Float, Float, Float);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct12BytesHomogeneousFloatResult = Completer<double>();
|
|
|
|
/// Return value in FPU registers, but does not use all registers on arm hardfp
|
|
/// and arm64.
|
|
void returnStruct12BytesHomogeneousFloat(double a0, double a1, double a2) {
|
|
print("returnStruct12BytesHomogeneousFloat(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStruct12BytesHomogeneousFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct12BytesHomogeneousFloatAfterCallback() async {
|
|
final result = await ReturnStruct12BytesHomogeneousFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStruct16BytesHomogeneousFloatType = Void Function(
|
|
Float, Float, Float, Float);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct16BytesHomogeneousFloatResult = Completer<double>();
|
|
|
|
/// Return value in FPU registers on arm hardfp and arm64.
|
|
void returnStruct16BytesHomogeneousFloat(
|
|
double a0, double a1, double a2, double a3) {
|
|
print("returnStruct16BytesHomogeneousFloat(${a0}, ${a1}, ${a2}, ${a3})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
|
|
print("result = $result");
|
|
ReturnStruct16BytesHomogeneousFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct16BytesHomogeneousFloatAfterCallback() async {
|
|
final result = await ReturnStruct16BytesHomogeneousFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2, result);
|
|
}
|
|
|
|
typedef ReturnStruct16BytesMixedType = Void Function(Double, Int64);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct16BytesMixedResult = Completer<double>();
|
|
|
|
/// Return value split over FP and integer register in x64.
|
|
void returnStruct16BytesMixed(double a0, int a1) {
|
|
print("returnStruct16BytesMixed(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct16BytesMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct16BytesMixedAfterCallback() async {
|
|
final result = await ReturnStruct16BytesMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct16BytesMixed2Type = Void Function(
|
|
Float, Float, Float, Int32);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct16BytesMixed2Result = Completer<double>();
|
|
|
|
/// Return value split over FP and integer register in x64.
|
|
/// The integer register contains half float half int.
|
|
void returnStruct16BytesMixed2(double a0, double a1, double a2, int a3) {
|
|
print("returnStruct16BytesMixed2(${a0}, ${a1}, ${a2}, ${a3})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
|
|
print("result = $result");
|
|
ReturnStruct16BytesMixed2Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct16BytesMixed2AfterCallback() async {
|
|
final result = await ReturnStruct16BytesMixed2Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2, result);
|
|
}
|
|
|
|
typedef ReturnStruct17BytesIntType = Void Function(Int64, Int64, Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct17BytesIntResult = Completer<double>();
|
|
|
|
/// Return value returned in preallocated space passed by pointer on most ABIs.
|
|
/// Is non word size on purpose, to test that structs are rounded up to word size
|
|
/// on all ABIs.
|
|
void returnStruct17BytesInt(int a0, int a1, int a2) {
|
|
print("returnStruct17BytesInt(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStruct17BytesIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct17BytesIntAfterCallback() async {
|
|
final result = await ReturnStruct17BytesIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStruct19BytesHomogeneousUint8Type = Void Function(
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8,
|
|
Uint8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct19BytesHomogeneousUint8Result = Completer<double>();
|
|
|
|
/// The minimum alignment of this struct is only 1 byte based on its fields.
|
|
/// Test that the memory backing these structs is the right size and that
|
|
/// dart:ffi trampolines do not write outside this size.
|
|
void returnStruct19BytesHomogeneousUint8(
|
|
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) {
|
|
print(
|
|
"returnStruct19BytesHomogeneousUint8(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9}, ${a10}, ${a11}, ${a12}, ${a13}, ${a14}, ${a15}, ${a16}, ${a17}, ${a18})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6;
|
|
result += a7;
|
|
result += a8;
|
|
result += a9;
|
|
result += a10;
|
|
result += a11;
|
|
result += a12;
|
|
result += a13;
|
|
result += a14;
|
|
result += a15;
|
|
result += a16;
|
|
result += a17;
|
|
result += a18;
|
|
|
|
print("result = $result");
|
|
ReturnStruct19BytesHomogeneousUint8Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct19BytesHomogeneousUint8AfterCallback() async {
|
|
final result = await ReturnStruct19BytesHomogeneousUint8Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(190, result);
|
|
}
|
|
|
|
typedef ReturnStruct20BytesHomogeneousInt32Type = Void Function(
|
|
Int32, Int32, Int32, Int32, Int32);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct20BytesHomogeneousInt32Result = Completer<double>();
|
|
|
|
/// Return value too big to go in cpu registers on arm64.
|
|
void returnStruct20BytesHomogeneousInt32(
|
|
int a0, int a1, int a2, int a3, int a4) {
|
|
print(
|
|
"returnStruct20BytesHomogeneousInt32(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
|
|
print("result = $result");
|
|
ReturnStruct20BytesHomogeneousInt32Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct20BytesHomogeneousInt32AfterCallback() async {
|
|
final result = await ReturnStruct20BytesHomogeneousInt32Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-3, result);
|
|
}
|
|
|
|
typedef ReturnStruct20BytesHomogeneousFloatType = Void Function(
|
|
Float, Float, Float, Float, Float);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct20BytesHomogeneousFloatResult = Completer<double>();
|
|
|
|
/// Return value too big to go in FPU registers on x64, arm hardfp and arm64.
|
|
void returnStruct20BytesHomogeneousFloat(
|
|
double a0, double a1, double a2, double a3, double a4) {
|
|
print(
|
|
"returnStruct20BytesHomogeneousFloat(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
|
|
print("result = $result");
|
|
ReturnStruct20BytesHomogeneousFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct20BytesHomogeneousFloatAfterCallback() async {
|
|
final result = await ReturnStruct20BytesHomogeneousFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-3, result);
|
|
}
|
|
|
|
typedef ReturnStruct32BytesHomogeneousDoubleType = Void Function(
|
|
Double, Double, Double, Double);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct32BytesHomogeneousDoubleResult = Completer<double>();
|
|
|
|
/// Return value in FPU registers on arm64.
|
|
void returnStruct32BytesHomogeneousDouble(
|
|
double a0, double a1, double a2, double a3) {
|
|
print("returnStruct32BytesHomogeneousDouble(${a0}, ${a1}, ${a2}, ${a3})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
|
|
print("result = $result");
|
|
ReturnStruct32BytesHomogeneousDoubleResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct32BytesHomogeneousDoubleAfterCallback() async {
|
|
final result = await ReturnStruct32BytesHomogeneousDoubleResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2, result);
|
|
}
|
|
|
|
typedef ReturnStruct40BytesHomogeneousDoubleType = Void Function(
|
|
Double, Double, Double, Double, Double);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct40BytesHomogeneousDoubleResult = Completer<double>();
|
|
|
|
/// Return value too big to go in FPU registers on arm64.
|
|
void returnStruct40BytesHomogeneousDouble(
|
|
double a0, double a1, double a2, double a3, double a4) {
|
|
print(
|
|
"returnStruct40BytesHomogeneousDouble(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
|
|
print("result = $result");
|
|
ReturnStruct40BytesHomogeneousDoubleResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct40BytesHomogeneousDoubleAfterCallback() async {
|
|
final result = await ReturnStruct40BytesHomogeneousDoubleResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-3, result);
|
|
}
|
|
|
|
typedef ReturnStruct1024BytesHomogeneousUint64Type = Void Function(
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64,
|
|
Uint64);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct1024BytesHomogeneousUint64Result = Completer<double>();
|
|
|
|
/// Test 1kb struct.
|
|
void returnStruct1024BytesHomogeneousUint64(
|
|
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,
|
|
int a20,
|
|
int a21,
|
|
int a22,
|
|
int a23,
|
|
int a24,
|
|
int a25,
|
|
int a26,
|
|
int a27,
|
|
int a28,
|
|
int a29,
|
|
int a30,
|
|
int a31,
|
|
int a32,
|
|
int a33,
|
|
int a34,
|
|
int a35,
|
|
int a36,
|
|
int a37,
|
|
int a38,
|
|
int a39,
|
|
int a40,
|
|
int a41,
|
|
int a42,
|
|
int a43,
|
|
int a44,
|
|
int a45,
|
|
int a46,
|
|
int a47,
|
|
int a48,
|
|
int a49,
|
|
int a50,
|
|
int a51,
|
|
int a52,
|
|
int a53,
|
|
int a54,
|
|
int a55,
|
|
int a56,
|
|
int a57,
|
|
int a58,
|
|
int a59,
|
|
int a60,
|
|
int a61,
|
|
int a62,
|
|
int a63,
|
|
int a64,
|
|
int a65,
|
|
int a66,
|
|
int a67,
|
|
int a68,
|
|
int a69,
|
|
int a70,
|
|
int a71,
|
|
int a72,
|
|
int a73,
|
|
int a74,
|
|
int a75,
|
|
int a76,
|
|
int a77,
|
|
int a78,
|
|
int a79,
|
|
int a80,
|
|
int a81,
|
|
int a82,
|
|
int a83,
|
|
int a84,
|
|
int a85,
|
|
int a86,
|
|
int a87,
|
|
int a88,
|
|
int a89,
|
|
int a90,
|
|
int a91,
|
|
int a92,
|
|
int a93,
|
|
int a94,
|
|
int a95,
|
|
int a96,
|
|
int a97,
|
|
int a98,
|
|
int a99,
|
|
int a100,
|
|
int a101,
|
|
int a102,
|
|
int a103,
|
|
int a104,
|
|
int a105,
|
|
int a106,
|
|
int a107,
|
|
int a108,
|
|
int a109,
|
|
int a110,
|
|
int a111,
|
|
int a112,
|
|
int a113,
|
|
int a114,
|
|
int a115,
|
|
int a116,
|
|
int a117,
|
|
int a118,
|
|
int a119,
|
|
int a120,
|
|
int a121,
|
|
int a122,
|
|
int a123,
|
|
int a124,
|
|
int a125,
|
|
int a126,
|
|
int a127) {
|
|
print(
|
|
"returnStruct1024BytesHomogeneousUint64(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8}, ${a9}, ${a10}, ${a11}, ${a12}, ${a13}, ${a14}, ${a15}, ${a16}, ${a17}, ${a18}, ${a19}, ${a20}, ${a21}, ${a22}, ${a23}, ${a24}, ${a25}, ${a26}, ${a27}, ${a28}, ${a29}, ${a30}, ${a31}, ${a32}, ${a33}, ${a34}, ${a35}, ${a36}, ${a37}, ${a38}, ${a39}, ${a40}, ${a41}, ${a42}, ${a43}, ${a44}, ${a45}, ${a46}, ${a47}, ${a48}, ${a49}, ${a50}, ${a51}, ${a52}, ${a53}, ${a54}, ${a55}, ${a56}, ${a57}, ${a58}, ${a59}, ${a60}, ${a61}, ${a62}, ${a63}, ${a64}, ${a65}, ${a66}, ${a67}, ${a68}, ${a69}, ${a70}, ${a71}, ${a72}, ${a73}, ${a74}, ${a75}, ${a76}, ${a77}, ${a78}, ${a79}, ${a80}, ${a81}, ${a82}, ${a83}, ${a84}, ${a85}, ${a86}, ${a87}, ${a88}, ${a89}, ${a90}, ${a91}, ${a92}, ${a93}, ${a94}, ${a95}, ${a96}, ${a97}, ${a98}, ${a99}, ${a100}, ${a101}, ${a102}, ${a103}, ${a104}, ${a105}, ${a106}, ${a107}, ${a108}, ${a109}, ${a110}, ${a111}, ${a112}, ${a113}, ${a114}, ${a115}, ${a116}, ${a117}, ${a118}, ${a119}, ${a120}, ${a121}, ${a122}, ${a123}, ${a124}, ${a125}, ${a126}, ${a127})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6;
|
|
result += a7;
|
|
result += a8;
|
|
result += a9;
|
|
result += a10;
|
|
result += a11;
|
|
result += a12;
|
|
result += a13;
|
|
result += a14;
|
|
result += a15;
|
|
result += a16;
|
|
result += a17;
|
|
result += a18;
|
|
result += a19;
|
|
result += a20;
|
|
result += a21;
|
|
result += a22;
|
|
result += a23;
|
|
result += a24;
|
|
result += a25;
|
|
result += a26;
|
|
result += a27;
|
|
result += a28;
|
|
result += a29;
|
|
result += a30;
|
|
result += a31;
|
|
result += a32;
|
|
result += a33;
|
|
result += a34;
|
|
result += a35;
|
|
result += a36;
|
|
result += a37;
|
|
result += a38;
|
|
result += a39;
|
|
result += a40;
|
|
result += a41;
|
|
result += a42;
|
|
result += a43;
|
|
result += a44;
|
|
result += a45;
|
|
result += a46;
|
|
result += a47;
|
|
result += a48;
|
|
result += a49;
|
|
result += a50;
|
|
result += a51;
|
|
result += a52;
|
|
result += a53;
|
|
result += a54;
|
|
result += a55;
|
|
result += a56;
|
|
result += a57;
|
|
result += a58;
|
|
result += a59;
|
|
result += a60;
|
|
result += a61;
|
|
result += a62;
|
|
result += a63;
|
|
result += a64;
|
|
result += a65;
|
|
result += a66;
|
|
result += a67;
|
|
result += a68;
|
|
result += a69;
|
|
result += a70;
|
|
result += a71;
|
|
result += a72;
|
|
result += a73;
|
|
result += a74;
|
|
result += a75;
|
|
result += a76;
|
|
result += a77;
|
|
result += a78;
|
|
result += a79;
|
|
result += a80;
|
|
result += a81;
|
|
result += a82;
|
|
result += a83;
|
|
result += a84;
|
|
result += a85;
|
|
result += a86;
|
|
result += a87;
|
|
result += a88;
|
|
result += a89;
|
|
result += a90;
|
|
result += a91;
|
|
result += a92;
|
|
result += a93;
|
|
result += a94;
|
|
result += a95;
|
|
result += a96;
|
|
result += a97;
|
|
result += a98;
|
|
result += a99;
|
|
result += a100;
|
|
result += a101;
|
|
result += a102;
|
|
result += a103;
|
|
result += a104;
|
|
result += a105;
|
|
result += a106;
|
|
result += a107;
|
|
result += a108;
|
|
result += a109;
|
|
result += a110;
|
|
result += a111;
|
|
result += a112;
|
|
result += a113;
|
|
result += a114;
|
|
result += a115;
|
|
result += a116;
|
|
result += a117;
|
|
result += a118;
|
|
result += a119;
|
|
result += a120;
|
|
result += a121;
|
|
result += a122;
|
|
result += a123;
|
|
result += a124;
|
|
result += a125;
|
|
result += a126;
|
|
result += a127;
|
|
|
|
print("result = $result");
|
|
ReturnStruct1024BytesHomogeneousUint64Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct1024BytesHomogeneousUint64AfterCallback() async {
|
|
final result = await ReturnStruct1024BytesHomogeneousUint64Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(8256, result);
|
|
}
|
|
|
|
typedef ReturnStruct3BytesPackedIntType = Void Function(Int8, Int16);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct3BytesPackedIntResult = Completer<double>();
|
|
|
|
/// Small struct with mis-aligned member.
|
|
void returnStruct3BytesPackedInt(int a0, int a1) {
|
|
print("returnStruct3BytesPackedInt(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct3BytesPackedIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct3BytesPackedIntAfterCallback() async {
|
|
final result = await ReturnStruct3BytesPackedIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesPackedIntType = Void Function(
|
|
Uint8, Uint32, Uint8, Uint8, Uint8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesPackedIntResult = Completer<double>();
|
|
|
|
/// Struct with mis-aligned member.
|
|
void returnStruct8BytesPackedInt(int a0, int a1, int a2, int a3, int a4) {
|
|
print("returnStruct8BytesPackedInt(${a0}, ${a1}, ${a2}, ${a3}, ${a4})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesPackedIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesPackedIntAfterCallback() async {
|
|
final result = await ReturnStruct8BytesPackedIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(15, result);
|
|
}
|
|
|
|
typedef ReturnStruct9BytesPackedMixedType = Void Function(Uint8, Double);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct9BytesPackedMixedResult = Completer<double>();
|
|
|
|
/// Struct with mis-aligned member.
|
|
/// Tests backfilling of CPU and FPU registers.
|
|
void returnStruct9BytesPackedMixed(int a0, double a1) {
|
|
print("returnStruct9BytesPackedMixed(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct9BytesPackedMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct9BytesPackedMixedAfterCallback() async {
|
|
final result = await ReturnStruct9BytesPackedMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef ReturnUnion4BytesMixedType = Void Function(Uint32);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnUnion4BytesMixedResult = Completer<double>();
|
|
|
|
/// Returning a mixed integer/float union.
|
|
void returnUnion4BytesMixed(int a0) {
|
|
print("returnUnion4BytesMixed(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
|
|
print("result = $result");
|
|
ReturnUnion4BytesMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnUnion4BytesMixedAfterCallback() async {
|
|
final result = await ReturnUnion4BytesMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnUnion8BytesNestedFloatType = Void Function(Double);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnUnion8BytesNestedFloatResult = Completer<double>();
|
|
|
|
/// Returning a floating point only union.
|
|
void returnUnion8BytesNestedFloat(double a0) {
|
|
print("returnUnion8BytesNestedFloat(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
|
|
print("result = $result");
|
|
ReturnUnion8BytesNestedFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnUnion8BytesNestedFloatAfterCallback() async {
|
|
final result = await ReturnUnion8BytesNestedFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-1, result);
|
|
}
|
|
|
|
typedef ReturnUnion9BytesNestedIntType = Void Function(Struct8BytesInt);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnUnion9BytesNestedIntResult = Completer<double>();
|
|
|
|
/// Returning a mixed-size union.
|
|
void returnUnion9BytesNestedInt(Struct8BytesInt a0) {
|
|
print("returnUnion9BytesNestedInt(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
|
|
print("result = $result");
|
|
ReturnUnion9BytesNestedIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnUnion9BytesNestedIntAfterCallback() async {
|
|
final result = await ReturnUnion9BytesNestedIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnUnion16BytesNestedFloatType = Void Function(
|
|
Struct8BytesHomogeneousFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnUnion16BytesNestedFloatResult = Completer<double>();
|
|
|
|
/// Returning union with homogenous floats.
|
|
void returnUnion16BytesNestedFloat(Struct8BytesHomogeneousFloat a0) {
|
|
print("returnUnion16BytesNestedFloat(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
|
|
print("result = $result");
|
|
ReturnUnion16BytesNestedFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnUnion16BytesNestedFloatAfterCallback() async {
|
|
final result = await ReturnUnion16BytesNestedFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentStruct1ByteIntType = Void Function(Struct1ByteInt);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentStruct1ByteIntResult = Completer<double>();
|
|
|
|
/// Test that a struct passed in as argument can be returned.
|
|
/// Especially for ffi callbacks.
|
|
/// Struct is passed in int registers in most ABIs.
|
|
void returnStructArgumentStruct1ByteInt(Struct1ByteInt a0) {
|
|
print("returnStructArgumentStruct1ByteInt(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentStruct1ByteIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructArgumentStruct1ByteIntAfterCallback() async {
|
|
final result = await ReturnStructArgumentStruct1ByteIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-1, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentInt32x8Struct1ByteIntType = Void Function(
|
|
Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Struct1ByteInt);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentInt32x8Struct1ByteIntResult = Completer<double>();
|
|
|
|
/// Test that a struct passed in as argument can be returned.
|
|
/// Especially for ffi callbacks.
|
|
/// Struct is passed on stack on all ABIs.
|
|
void returnStructArgumentInt32x8Struct1ByteInt(int a0, int a1, int a2, int a3,
|
|
int a4, int a5, int a6, int a7, Struct1ByteInt a8) {
|
|
print(
|
|
"returnStructArgumentInt32x8Struct1ByteInt(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6;
|
|
result += a7;
|
|
result += a8.a0;
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentInt32x8Struct1ByteIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructArgumentInt32x8Struct1ByteIntAfterCallback() async {
|
|
final result = await ReturnStructArgumentInt32x8Struct1ByteIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-5, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentStruct8BytesHomogeneousFloatType = Void Function(
|
|
Struct8BytesHomogeneousFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentStruct8BytesHomogeneousFloatResult =
|
|
Completer<double>();
|
|
|
|
/// Test that a struct passed in as argument can be returned.
|
|
/// Especially for ffi callbacks.
|
|
/// Struct is passed in float registers in most ABIs.
|
|
void returnStructArgumentStruct8BytesHomogeneousFloat(
|
|
Struct8BytesHomogeneousFloat a0) {
|
|
print("returnStructArgumentStruct8BytesHomogeneousFloat(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentStruct8BytesHomogeneousFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
returnStructArgumentStruct8BytesHomogeneousFloatAfterCallback() async {
|
|
final result =
|
|
await ReturnStructArgumentStruct8BytesHomogeneousFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentStruct20BytesHomogeneousInt32Type = Void Function(
|
|
Struct20BytesHomogeneousInt32);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentStruct20BytesHomogeneousInt32Result =
|
|
Completer<double>();
|
|
|
|
/// On arm64, both argument and return value are passed in by pointer.
|
|
void returnStructArgumentStruct20BytesHomogeneousInt32(
|
|
Struct20BytesHomogeneousInt32 a0) {
|
|
print("returnStructArgumentStruct20BytesHomogeneousInt32(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a0.a3;
|
|
result += a0.a4;
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentStruct20BytesHomogeneousInt32Result.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
returnStructArgumentStruct20BytesHomogeneousInt32AfterCallback() async {
|
|
final result =
|
|
await ReturnStructArgumentStruct20BytesHomogeneousInt32Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-3, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentInt32x8Struct20BytesHomogeneouType = Void Function(
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Int32,
|
|
Struct20BytesHomogeneousInt32);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentInt32x8Struct20BytesHomogeneouResult =
|
|
Completer<double>();
|
|
|
|
/// On arm64, both argument and return value are passed in by pointer.
|
|
/// Ints exhaust registers, so that pointer is passed on stack.
|
|
void returnStructArgumentInt32x8Struct20BytesHomogeneou(int a0, int a1, int a2,
|
|
int a3, int a4, int a5, int a6, int a7, Struct20BytesHomogeneousInt32 a8) {
|
|
print(
|
|
"returnStructArgumentInt32x8Struct20BytesHomogeneou(${a0}, ${a1}, ${a2}, ${a3}, ${a4}, ${a5}, ${a6}, ${a7}, ${a8})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
result += a3;
|
|
result += a4;
|
|
result += a5;
|
|
result += a6;
|
|
result += a7;
|
|
result += a8.a0;
|
|
result += a8.a1;
|
|
result += a8.a2;
|
|
result += a8.a3;
|
|
result += a8.a4;
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentInt32x8Struct20BytesHomogeneouResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
returnStructArgumentInt32x8Struct20BytesHomogeneouAfterCallback() async {
|
|
final result =
|
|
await ReturnStructArgumentInt32x8Struct20BytesHomogeneouResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-7, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentStruct8BytesInlineArrayIntType = Void Function(
|
|
Struct8BytesInlineArrayInt);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentStruct8BytesInlineArrayIntResult =
|
|
Completer<double>();
|
|
|
|
/// Test returning struct with inline array.
|
|
void returnStructArgumentStruct8BytesInlineArrayInt(
|
|
Struct8BytesInlineArrayInt a0) {
|
|
print("returnStructArgumentStruct8BytesInlineArrayInt(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0[0];
|
|
result += a0.a0[1];
|
|
result += a0.a0[2];
|
|
result += a0.a0[3];
|
|
result += a0.a0[4];
|
|
result += a0.a0[5];
|
|
result += a0.a0[6];
|
|
result += a0.a0[7];
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentStruct8BytesInlineArrayIntResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
returnStructArgumentStruct8BytesInlineArrayIntAfterCallback() async {
|
|
final result =
|
|
await ReturnStructArgumentStruct8BytesInlineArrayIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(36, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentStructStruct16BytesHomogeneousType = Void Function(
|
|
StructStruct16BytesHomogeneousFloat2);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentStructStruct16BytesHomogeneousResult =
|
|
Completer<double>();
|
|
|
|
/// Return value in FPU registers on arm hardfp and arm64.
|
|
void returnStructArgumentStructStruct16BytesHomogeneous(
|
|
StructStruct16BytesHomogeneousFloat2 a0) {
|
|
print("returnStructArgumentStructStruct16BytesHomogeneous(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1[0].a0;
|
|
result += a0.a1[1].a0;
|
|
result += a0.a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentStructStruct16BytesHomogeneousResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
returnStructArgumentStructStruct16BytesHomogeneousAfterCallback() async {
|
|
final result =
|
|
await ReturnStructArgumentStructStruct16BytesHomogeneousResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentStructStruct32BytesHomogeneousType = Void Function(
|
|
StructStruct32BytesHomogeneousDouble2);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentStructStruct32BytesHomogeneousResult =
|
|
Completer<double>();
|
|
|
|
/// Return value in FPU registers on arm64.
|
|
void returnStructArgumentStructStruct32BytesHomogeneous(
|
|
StructStruct32BytesHomogeneousDouble2 a0) {
|
|
print("returnStructArgumentStructStruct32BytesHomogeneous(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1[0].a0;
|
|
result += a0.a1[1].a0;
|
|
result += a0.a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentStructStruct32BytesHomogeneousResult.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
returnStructArgumentStructStruct32BytesHomogeneousAfterCallback() async {
|
|
final result =
|
|
await ReturnStructArgumentStructStruct32BytesHomogeneousResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2, result);
|
|
}
|
|
|
|
typedef ReturnStructArgumentStructStruct16BytesMixed3Type = Void Function(
|
|
StructStruct16BytesMixed3);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructArgumentStructStruct16BytesMixed3Result = Completer<double>();
|
|
|
|
/// On x64 Linux, return value is split over FP and int registers.
|
|
void returnStructArgumentStructStruct16BytesMixed3(
|
|
StructStruct16BytesMixed3 a0) {
|
|
print("returnStructArgumentStructStruct16BytesMixed3(${a0})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a1[0].a0;
|
|
result += a0.a1[0].a1;
|
|
result += a0.a1[0].a2;
|
|
result += a0.a2[0];
|
|
result += a0.a2[1];
|
|
|
|
print("result = $result");
|
|
ReturnStructArgumentStructStruct16BytesMixed3Result.complete(result);
|
|
}
|
|
|
|
Future<void>
|
|
returnStructArgumentStructStruct16BytesMixed3AfterCallback() async {
|
|
final result =
|
|
await ReturnStructArgumentStructStruct16BytesMixed3Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef ReturnStructAlignmentInt16Type = Void Function(Int8, Int16, Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructAlignmentInt16Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of 16 byte int within struct.
|
|
void returnStructAlignmentInt16(int a0, int a1, int a2) {
|
|
print("returnStructAlignmentInt16(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructAlignmentInt16Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructAlignmentInt16AfterCallback() async {
|
|
final result = await ReturnStructAlignmentInt16Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStructAlignmentInt32Type = Void Function(Int8, Int32, Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructAlignmentInt32Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of 32 byte int within struct.
|
|
void returnStructAlignmentInt32(int a0, int a1, int a2) {
|
|
print("returnStructAlignmentInt32(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructAlignmentInt32Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructAlignmentInt32AfterCallback() async {
|
|
final result = await ReturnStructAlignmentInt32Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStructAlignmentInt64Type = Void Function(Int8, Int64, Int8);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructAlignmentInt64Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of 64 byte int within struct.
|
|
void returnStructAlignmentInt64(int a0, int a1, int a2) {
|
|
print("returnStructAlignmentInt64(${a0}, ${a1}, ${a2})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1;
|
|
result += a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructAlignmentInt64Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructAlignmentInt64AfterCallback() async {
|
|
final result = await ReturnStructAlignmentInt64Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesNestedIntType = Void Function(
|
|
Struct4BytesHomogeneousInt16, Struct4BytesHomogeneousInt16);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesNestedIntResult = Completer<double>();
|
|
|
|
/// Simple nested struct.
|
|
void returnStruct8BytesNestedInt(
|
|
Struct4BytesHomogeneousInt16 a0, Struct4BytesHomogeneousInt16 a1) {
|
|
print("returnStruct8BytesNestedInt(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesNestedIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesNestedIntAfterCallback() async {
|
|
final result = await ReturnStruct8BytesNestedIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(2, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesNestedFloatType = Void Function(
|
|
Struct4BytesFloat, Struct4BytesFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesNestedFloatResult = Completer<double>();
|
|
|
|
/// Simple nested struct with floats.
|
|
void returnStruct8BytesNestedFloat(Struct4BytesFloat a0, Struct4BytesFloat a1) {
|
|
print("returnStruct8BytesNestedFloat(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a1.a0;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesNestedFloatResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesNestedFloatAfterCallback() async {
|
|
final result = await ReturnStruct8BytesNestedFloatResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesNestedFloat2Type = Void Function(
|
|
Struct4BytesFloat, Float);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesNestedFloat2Result = Completer<double>();
|
|
|
|
/// The nesting is irregular, testing homogenous float rules on arm and arm64,
|
|
/// and the fpu register usage on x64.
|
|
void returnStruct8BytesNestedFloat2(Struct4BytesFloat a0, double a1) {
|
|
print("returnStruct8BytesNestedFloat2(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesNestedFloat2Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesNestedFloat2AfterCallback() async {
|
|
final result = await ReturnStruct8BytesNestedFloat2Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(1, result);
|
|
}
|
|
|
|
typedef ReturnStruct8BytesNestedMixedType = Void Function(
|
|
Struct4BytesHomogeneousInt16, Struct4BytesFloat);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct8BytesNestedMixedResult = Completer<double>();
|
|
|
|
/// Simple nested struct with mixed members.
|
|
void returnStruct8BytesNestedMixed(
|
|
Struct4BytesHomogeneousInt16 a0, Struct4BytesFloat a1) {
|
|
print("returnStruct8BytesNestedMixed(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a1.a0;
|
|
|
|
print("result = $result");
|
|
ReturnStruct8BytesNestedMixedResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct8BytesNestedMixedAfterCallback() async {
|
|
final result = await ReturnStruct8BytesNestedMixedResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(-2, result);
|
|
}
|
|
|
|
typedef ReturnStruct16BytesNestedIntType = Void Function(
|
|
Struct8BytesNestedInt, Struct8BytesNestedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct16BytesNestedIntResult = Completer<double>();
|
|
|
|
/// Deeper nested struct to test recursive member access.
|
|
void returnStruct16BytesNestedInt(
|
|
Struct8BytesNestedInt a0, Struct8BytesNestedInt a1) {
|
|
print("returnStruct16BytesNestedInt(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0;
|
|
result += a0.a0.a1;
|
|
result += a0.a1.a0;
|
|
result += a0.a1.a1;
|
|
result += a1.a0.a0;
|
|
result += a1.a0.a1;
|
|
result += a1.a1.a0;
|
|
result += a1.a1.a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct16BytesNestedIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct16BytesNestedIntAfterCallback() async {
|
|
final result = await ReturnStruct16BytesNestedIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(4, result);
|
|
}
|
|
|
|
typedef ReturnStruct32BytesNestedIntType = Void Function(
|
|
Struct16BytesNestedInt, Struct16BytesNestedInt);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStruct32BytesNestedIntResult = Completer<double>();
|
|
|
|
/// Even deeper nested struct to test recursive member access.
|
|
void returnStruct32BytesNestedInt(
|
|
Struct16BytesNestedInt a0, Struct16BytesNestedInt a1) {
|
|
print("returnStruct32BytesNestedInt(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0.a0.a0;
|
|
result += a0.a0.a0.a1;
|
|
result += a0.a0.a1.a0;
|
|
result += a0.a0.a1.a1;
|
|
result += a0.a1.a0.a0;
|
|
result += a0.a1.a0.a1;
|
|
result += a0.a1.a1.a0;
|
|
result += a0.a1.a1.a1;
|
|
result += a1.a0.a0.a0;
|
|
result += a1.a0.a0.a1;
|
|
result += a1.a0.a1.a0;
|
|
result += a1.a0.a1.a1;
|
|
result += a1.a1.a0.a0;
|
|
result += a1.a1.a0.a1;
|
|
result += a1.a1.a1.a0;
|
|
result += a1.a1.a1.a1;
|
|
|
|
print("result = $result");
|
|
ReturnStruct32BytesNestedIntResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStruct32BytesNestedIntAfterCallback() async {
|
|
final result = await ReturnStruct32BytesNestedIntResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(8, result);
|
|
}
|
|
|
|
typedef ReturnStructNestedIntStructAlignmentInt16Type = Void Function(
|
|
StructAlignmentInt16, StructAlignmentInt16);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructNestedIntStructAlignmentInt16Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of nested struct with 16 byte int.
|
|
void returnStructNestedIntStructAlignmentInt16(
|
|
StructAlignmentInt16 a0, StructAlignmentInt16 a1) {
|
|
print("returnStructNestedIntStructAlignmentInt16(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructNestedIntStructAlignmentInt16Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructNestedIntStructAlignmentInt16AfterCallback() async {
|
|
final result = await ReturnStructNestedIntStructAlignmentInt16Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef ReturnStructNestedIntStructAlignmentInt32Type = Void Function(
|
|
StructAlignmentInt32, StructAlignmentInt32);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructNestedIntStructAlignmentInt32Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of nested struct with 32 byte int.
|
|
void returnStructNestedIntStructAlignmentInt32(
|
|
StructAlignmentInt32 a0, StructAlignmentInt32 a1) {
|
|
print("returnStructNestedIntStructAlignmentInt32(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructNestedIntStructAlignmentInt32Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructNestedIntStructAlignmentInt32AfterCallback() async {
|
|
final result = await ReturnStructNestedIntStructAlignmentInt32Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef ReturnStructNestedIntStructAlignmentInt64Type = Void Function(
|
|
StructAlignmentInt64, StructAlignmentInt64);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructNestedIntStructAlignmentInt64Result = Completer<double>();
|
|
|
|
/// Test alignment and padding of nested struct with 64 byte int.
|
|
void returnStructNestedIntStructAlignmentInt64(
|
|
StructAlignmentInt64 a0, StructAlignmentInt64 a1) {
|
|
print("returnStructNestedIntStructAlignmentInt64(${a0}, ${a1})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0.a0;
|
|
result += a0.a1;
|
|
result += a0.a2;
|
|
result += a1.a0;
|
|
result += a1.a1;
|
|
result += a1.a2;
|
|
|
|
print("result = $result");
|
|
ReturnStructNestedIntStructAlignmentInt64Result.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructNestedIntStructAlignmentInt64AfterCallback() async {
|
|
final result = await ReturnStructNestedIntStructAlignmentInt64Result.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(3, result);
|
|
}
|
|
|
|
typedef ReturnStructNestedIrregularEvenBiggerType = Void Function(
|
|
Uint64, StructNestedIrregularBigger, StructNestedIrregularBigger, Double);
|
|
|
|
// Global variable that stores the result.
|
|
final ReturnStructNestedIrregularEvenBiggerResult = Completer<double>();
|
|
|
|
/// Return big irregular struct as smoke test.
|
|
void returnStructNestedIrregularEvenBigger(int a0,
|
|
StructNestedIrregularBigger a1, StructNestedIrregularBigger a2, double a3) {
|
|
print("returnStructNestedIrregularEvenBigger(${a0}, ${a1}, ${a2}, ${a3})");
|
|
|
|
double result = 0;
|
|
|
|
result += a0;
|
|
result += a1.a0.a0;
|
|
result += a1.a0.a1.a0.a0;
|
|
result += a1.a0.a1.a0.a1;
|
|
result += a1.a0.a1.a1.a0;
|
|
result += a1.a0.a2;
|
|
result += a1.a0.a3.a0.a0;
|
|
result += a1.a0.a3.a1;
|
|
result += a1.a0.a4;
|
|
result += a1.a0.a5.a0.a0;
|
|
result += a1.a0.a5.a1.a0;
|
|
result += a1.a0.a6;
|
|
result += a1.a1.a0.a0;
|
|
result += a1.a1.a0.a1;
|
|
result += a1.a1.a1.a0;
|
|
result += a1.a2;
|
|
result += a1.a3;
|
|
result += a2.a0.a0;
|
|
result += a2.a0.a1.a0.a0;
|
|
result += a2.a0.a1.a0.a1;
|
|
result += a2.a0.a1.a1.a0;
|
|
result += a2.a0.a2;
|
|
result += a2.a0.a3.a0.a0;
|
|
result += a2.a0.a3.a1;
|
|
result += a2.a0.a4;
|
|
result += a2.a0.a5.a0.a0;
|
|
result += a2.a0.a5.a1.a0;
|
|
result += a2.a0.a6;
|
|
result += a2.a1.a0.a0;
|
|
result += a2.a1.a0.a1;
|
|
result += a2.a1.a1.a0;
|
|
result += a2.a2;
|
|
result += a2.a3;
|
|
result += a3;
|
|
|
|
print("result = $result");
|
|
ReturnStructNestedIrregularEvenBiggerResult.complete(result);
|
|
}
|
|
|
|
Future<void> returnStructNestedIrregularEvenBiggerAfterCallback() async {
|
|
final result = await ReturnStructNestedIrregularEvenBiggerResult.future;
|
|
print("after callback result = $result");
|
|
Expect.approxEquals(87, result);
|
|
}
|