| 1 |
/* { dg-do link } */ |
| 2 |
/* { dg-do run { target nvptx_runtime_alloca_ptx } } */ |
| 3 |
/* { dg-options {-O2 -mno-soft-stack} } */ |
| 4 |
/* { dg-add-options nvptx_alloca_ptx } */ |
| 5 |
/* { dg-additional-options -save-temps } */ |
| 6 |
/* { dg-final { check-function-bodies {** } {} } } */ |
| 7 |
|
| 8 |
/* See also 'gcc.target/nvptx/softstack.c'. */ |
| 9 |
|
| 10 |
static __attribute__((noipa)) int f(int *p) |
| 11 |
{ |
| 12 |
return __sync_lock_test_and_set(p, 1); |
| 13 |
} |
| 14 |
/* |
| 15 |
** f: |
| 16 |
** \.func \(\.param\.u32 %value_out\) f \(\.param\.u64 %in_ar0\) |
| 17 |
** { |
| 18 |
** \.reg\.u32 %value; |
| 19 |
** \.reg\.u64 %ar0; |
| 20 |
** ld\.param\.u64 %ar0, \[%in_ar0\]; |
| 21 |
** \.reg\.u32 (%r[0-9]+); |
| 22 |
** \.reg\.u64 (%r[0-9]+); |
| 23 |
** mov\.u64 \2, %ar0; |
| 24 |
** atom\.exch\.b32 \1, \[\2\], 1; |
| 25 |
** membar\.sys; |
| 26 |
** mov\.u32 %value, \1; |
| 27 |
** st\.param\.u32 \[%value_out\], %value; |
| 28 |
** ret; |
| 29 |
*/ |
| 30 |
|
| 31 |
static __attribute__((noipa)) int g(int n) |
| 32 |
{ |
| 33 |
/* Check that variable-length stack allocation works. */ |
| 34 |
int v[n]; |
| 35 |
v[0] = 0; |
| 36 |
/* Check that atomic operations can be applied to auto data. */ |
| 37 |
return f(v) == 0 && v[0] == 1; |
| 38 |
} |
| 39 |
/* |
| 40 |
** g: |
| 41 |
** \.func \(\.param\.u32 %value_out\) g \(\.param\.u32 %in_ar0\) |
| 42 |
** { |
| 43 |
** \.reg\.u32 %value; |
| 44 |
** \.reg\.u32 %ar0; |
| 45 |
** ld\.param\.u32 %ar0, \[%in_ar0\]; |
| 46 |
** \.reg\.u32 (%r[0-9]+); |
| 47 |
** \.reg\.u32 (%r[0-9]+); |
| 48 |
** \.reg\.u64 (%r[0-9]+); |
| 49 |
** \.reg\.u64 (%r[0-9]+); |
| 50 |
** \.reg\.u64 (%r[0-9]+); |
| 51 |
** \.reg\.u64 (%r[0-9]+); |
| 52 |
** \.reg\.u64 (%r[0-9]+); |
| 53 |
** \.reg\.u64 (%r[0-9]+); |
| 54 |
** \.reg\.u64 (%r[0-9]+); |
| 55 |
** \.reg\.u32 (%r[0-9]+); |
| 56 |
** \.reg\.u32 (%r[0-9]+); |
| 57 |
** \.reg\.pred (%r[0-9]+); |
| 58 |
** \.reg\.u32 (%r[0-9]+); |
| 59 |
** \.reg\.pred (%r[0-9]+); |
| 60 |
** mov\.u32 \2, %ar0; |
| 61 |
** cvt\.s64\.s32 \3, \2; |
| 62 |
** shl\.b64 \4, \3, 2; |
| 63 |
** add\.u64 \5, \4, 15; |
| 64 |
** and\.b64 \6, \5, -16; |
| 65 |
** { |
| 66 |
** \.reg\.u64 \7_local; |
| 67 |
** alloca\.u64 \7_local, \6; |
| 68 |
** cvta\.local\.u64 \7, \7_local; |
| 69 |
** } |
| 70 |
** add\.u64 \8, \7, 3; |
| 71 |
** and\.b64 \9, \8, -4; |
| 72 |
** mov\.u32 \10, 0; |
| 73 |
** st\.u32 \[\9\], \10; |
| 74 |
** { |
| 75 |
** \.param\.u32 %value_in; |
| 76 |
** \.param\.u64 %out_arg1; |
| 77 |
** st\.param\.u64 \[%out_arg1\], \9; |
| 78 |
** call \(%value_in\), f, \(%out_arg1\); |
| 79 |
** ld\.param\.u32 \11, \[%value_in\]; |
| 80 |
** } |
| 81 |
** setp\.ne\.u32 \12, \11, 0; |
| 82 |
** @\12 bra (\$L[0-9]+); |
| 83 |
** ld\.u32 \13, \[\9\]; |
| 84 |
** setp\.eq\.u32 \14, \13, 1; |
| 85 |
** selp\.u32 \1, 1, 0, \14; |
| 86 |
** bra (\$L[0-9]+); |
| 87 |
** \15: |
| 88 |
** mov\.u32 \1, \10; |
| 89 |
** \16: |
| 90 |
** mov\.u32 %value, \1; |
| 91 |
** st\.param\.u32 \[%value_out\], %value; |
| 92 |
** ret; |
| 93 |
*/ |
| 94 |
|
| 95 |
int main() |
| 96 |
{ |
| 97 |
if (!g(1)) |
| 98 |
__builtin_abort(); |
| 99 |
return 0; |
| 100 |
} |
| 101 |
|
| 102 |
/* PTX 'atom' isn't acceptable for '.local' memory: |
| 103 |
'operation not supported on global/shared address space' [sic] |
| 104 |
('CUDA_ERROR_INVALID_ADDRESS_SPACE'), thus FAILs for 'alloca'ed memory. |
| 105 |
We'd have to use the 'nvptx_mem_local_p' replacements, but currently lack a |
| 106 |
mechanism for doing so (TODO). |
| 107 |
{ dg-xfail-run-if TODO { *-*-* } } */ |