| 1 | // RUN: %clang_cc1 -triple aarch64-linux-gnu -target-feature +neon -target-abi aapcs -ffreestanding -fallow-half-arguments-and-returns -emit-llvm -w -o - %s | FileCheck %s |
|---|
| 2 | |
|---|
| 3 | // AAPCS clause C.8 says: If the argument has an alignment of 16 then the NGRN |
|---|
| 4 | // is rounded up to the next even number. |
|---|
| 5 | |
|---|
| 6 | // CHECK: void @test1(i32 %x0, i128 %x2_x3, i128 %x4_x5, i128 %x6_x7, i128 %sp.coerce) |
|---|
| 7 | typedef union { __int128 a; } Small; |
|---|
| 8 | void test1(int x0, __int128 x2_x3, __int128 x4_x5, __int128 x6_x7, Small sp) { |
|---|
| 9 | } |
|---|
| 10 | |
|---|
| 11 | |
|---|
| 12 | // CHECK: void @test2(i32 %x0, i128 %x2_x3.coerce, i32 %x4, i128 %x6_x7.coerce, i32 %sp, i128 %sp16.coerce) |
|---|
| 13 | void test2(int x0, Small x2_x3, int x4, Small x6_x7, int sp, Small sp16) { |
|---|
| 14 | } |
|---|
| 15 | |
|---|
| 16 | // We coerce HFAs into a contiguous [N x double] type if they're going on the |
|---|
| 17 | // stack in order to avoid holes. Make sure we get all of them, and not just the |
|---|
| 18 | // first: |
|---|
| 19 | |
|---|
| 20 | // CHECK: void @test3([4 x float] %s0_s3.coerce, float %s4, [4 x float] %sp.coerce, [4 x float] %sp16.coerce) |
|---|
| 21 | typedef struct { float arr[4]; } HFA; |
|---|
| 22 | void test3(HFA s0_s3, float s4, HFA sp, HFA sp16) { |
|---|
| 23 | } |
|---|
| 24 | |
|---|
| 25 | |
|---|
| 26 | // However, we shouldn't perform the [N x double] coercion on types which have |
|---|
| 27 | // sufficient alignment to avoid holes on their own. We could coerce to [N x |
|---|
| 28 | // fp128] or something, but leaving them as-is retains more information for |
|---|
| 29 | // users to debug. |
|---|
| 30 | |
|---|
| 31 | // CHECK: void @test4([3 x <16 x i8>] %v0_v2.coerce, [3 x <16 x i8>] %v3_v5.coerce, [3 x <16 x i8>] %sp.coerce, double %sp48, [3 x <16 x i8>] %sp64.coerce) |
|---|
| 32 | typedef __attribute__((neon_vector_type(16))) signed char int8x16_t; |
|---|
| 33 | typedef struct { int8x16_t arr[3]; } BigHFA; |
|---|
| 34 | void test4(BigHFA v0_v2, BigHFA v3_v5, BigHFA sp, double sp48, BigHFA sp64) { |
|---|
| 35 | } |
|---|
| 36 | |
|---|
| 37 | // It's the job of the argument *consumer* to perform the required sign & zero |
|---|
| 38 | // extensions under AAPCS. There shouldn't be |
|---|
| 39 | |
|---|
| 40 | // CHECK: define i8 @test5(i8 %a, i16 %b) |
|---|
| 41 | unsigned char test5(unsigned char a, signed short b) { |
|---|
| 42 | } |
|---|
| 43 | |
|---|
| 44 | // __fp16 can be used as a function argument or return type (ACLE 2.0) |
|---|
| 45 | // CHECK: define half @test_half(half %{{.*}}) |
|---|
| 46 | __fp16 test_half(__fp16 A) { } |
|---|
| 47 | |
|---|
| 48 | // __fp16 is a base type for homogeneous floating-point aggregates for AArch64 (but not 32-bit ARM). |
|---|
| 49 | // CHECK: define %struct.HFA_half @test_half_hfa([4 x half] %{{.*}}) |
|---|
| 50 | struct HFA_half { __fp16 a[4]; }; |
|---|
| 51 | struct HFA_half test_half_hfa(struct HFA_half A) { } |
|---|
| 52 | |
|---|