1 // REQUIRES: powerpc-registered-target 2 // RUN: %clang_cc1 -triple powerpc64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s 3 // RUN: %clang_cc1 -target-feature +float128 -DTEST_F128 -triple \ 4 // RUN: powerpc64le-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s \ 5 // RUN: --check-prefix CHECK-F128 6 7 float crealf(_Complex float); 8 double creal(_Complex double); 9 long double creall(_Complex long double); 10 #ifdef TEST_F128 11 __float128 crealf128(_Complex __float128); 12 _Complex __float128 foo_f128(_Complex __float128 x) { 13 return x; 14 } 15 16 // CHECK-F128: define{{.*}} { fp128, fp128 } @foo_f128(fp128 noundef {{[%A-Za-z0-9.]+}}, fp128 noundef {{[%A-Za-z0-9.]+}}) [[NUW:#[0-9]+]] { 17 #endif 18 19 _Complex float foo_float(_Complex float x) { 20 return x; 21 } 22 23 // CHECK: define{{.*}} { float, float } @foo_float(float noundef {{[%A-Za-z0-9.]+}}, float noundef {{[%A-Za-z0-9.]+}}) [[NUW:#[0-9]+]] { 24 25 _Complex double foo_double(_Complex double x) { 26 return x; 27 } 28 29 // CHECK: define{{.*}} { double, double } @foo_double(double noundef {{[%A-Za-z0-9.]+}}, double noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 30 31 _Complex long double foo_long_double(_Complex long double x) { 32 return x; 33 } 34 35 // CHECK: define{{.*}} { ppc_fp128, ppc_fp128 } @foo_long_double(ppc_fp128 noundef {{[%A-Za-z0-9.]+}}, ppc_fp128 noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 36 37 _Complex __ibm128 foo_ibm128(_Complex __ibm128 x) { 38 return x; 39 } 40 41 // CHECK: define{{.*}} { ppc_fp128, ppc_fp128 } @foo_ibm128(ppc_fp128 noundef {{[%A-Za-z0-9.]+}}, ppc_fp128 noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 42 43 _Complex int foo_int(_Complex int x) { 44 return x; 45 } 46 47 // CHECK: define{{.*}} { i32, i32 } @foo_int(i32 noundef {{[%A-Za-z0-9.]+}}, i32 noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 48 49 _Complex short foo_short(_Complex short x) { 50 return x; 51 } 52 53 // CHECK: define{{.*}} { i16, i16 } @foo_short(i16 noundef {{[%A-Za-z0-9.]+}}, i16 noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 54 55 _Complex signed char foo_char(_Complex signed char x) { 56 return x; 57 } 58 59 // CHECK: define{{.*}} { i8, i8 } @foo_char(i8 noundef {{[%A-Za-z0-9.]+}}, i8 noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 60 61 _Complex long foo_long(_Complex long x) { 62 return x; 63 } 64 65 // CHECK: define{{.*}} { i64, i64 } @foo_long(i64 noundef {{[%A-Za-z0-9.]+}}, i64 noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 66 67 _Complex long long foo_long_long(_Complex long long x) { 68 return x; 69 } 70 71 // CHECK: define{{.*}} { i64, i64 } @foo_long_long(i64 noundef {{[%A-Za-z0-9.]+}}, i64 noundef {{[%A-Za-z0-9.]+}}) [[NUW]] { 72 73 float bar_float(void) { 74 return crealf(foo_float(2.0f - 2.5fi)); 75 } 76 77 // CHECK: define{{.*}} float @bar_float() [[NUW]] { 78 // CHECK: [[VAR1:[%A-Za-z0-9.]+]] = call { float, float } @foo_float 79 // CHECK: extractvalue { float, float } [[VAR1]], 0 80 // CHECK: extractvalue { float, float } [[VAR1]], 1 81 82 double bar_double(void) { 83 return creal(foo_double(2.0 - 2.5i)); 84 } 85 86 // CHECK: define{{.*}} double @bar_double() [[NUW]] { 87 // CHECK: [[VAR2:[%A-Za-z0-9.]+]] = call { double, double } @foo_double 88 // CHECK: extractvalue { double, double } [[VAR2]], 0 89 // CHECK: extractvalue { double, double } [[VAR2]], 1 90 91 long double bar_long_double(void) { 92 return creall(foo_long_double(2.0L - 2.5Li)); 93 } 94 95 // CHECK: define{{.*}} ppc_fp128 @bar_long_double() [[NUW]] { 96 // CHECK: [[VAR3:[%A-Za-z0-9.]+]] = call { ppc_fp128, ppc_fp128 } @foo_long_double 97 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 0 98 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 1 99 100 __ibm128 bar_ibm128(void) { 101 return creall(foo_ibm128(2.0L - 2.5Li)); 102 } 103 104 // CHECK: define{{.*}} ppc_fp128 @bar_ibm128() [[NUW]] { 105 // CHECK: [[VAR3:[%A-Za-z0-9.]+]] = call { ppc_fp128, ppc_fp128 } @foo_ibm128 106 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 0 107 // CHECK: extractvalue { ppc_fp128, ppc_fp128 } [[VAR3]], 1 108 109 #ifdef TEST_F128 110 __float128 bar_f128(void) { 111 return crealf128(foo_f128(2.0Q - 2.5Qi)); 112 } 113 114 // CHECK-F128: define{{.*}} fp128 @bar_f128() [[NUW]] { 115 // CHECK-F128: [[VAR3:[%A-Za-z0-9.]+]] = call { fp128, fp128 } @foo_f128 116 // CHECK-F128: extractvalue { fp128, fp128 } [[VAR3]], 0 117 // CHECK-F128: extractvalue { fp128, fp128 } [[VAR3]], 1 118 #endif 119 120 int bar_int(void) { 121 return __real__(foo_int(2 - 3i)); 122 } 123 124 // CHECK: define{{.*}} signext i32 @bar_int() [[NUW]] { 125 // CHECK: [[VAR4:[%A-Za-z0-9.]+]] = call { i32, i32 } @foo_int 126 // CHECK: extractvalue { i32, i32 } [[VAR4]], 0 127 // CHECK: extractvalue { i32, i32 } [[VAR4]], 1 128 129 short bar_short(void) { 130 return __real__(foo_short(2 - 3i)); 131 } 132 133 // CHECK: define{{.*}} signext i16 @bar_short() [[NUW]] { 134 // CHECK: [[VAR5:[%A-Za-z0-9.]+]] = call { i16, i16 } @foo_short 135 // CHECK: extractvalue { i16, i16 } [[VAR5]], 0 136 // CHECK: extractvalue { i16, i16 } [[VAR5]], 1 137 138 signed char bar_char(void) { 139 return __real__(foo_char(2 - 3i)); 140 } 141 142 // CHECK: define{{.*}} signext i8 @bar_char() [[NUW]] { 143 // CHECK: [[VAR6:[%A-Za-z0-9.]+]] = call { i8, i8 } @foo_char 144 // CHECK: extractvalue { i8, i8 } [[VAR6]], 0 145 // CHECK: extractvalue { i8, i8 } [[VAR6]], 1 146 147 long bar_long(void) { 148 return __real__(foo_long(2L - 3Li)); 149 } 150 151 // CHECK: define{{.*}} i64 @bar_long() [[NUW]] { 152 // CHECK: [[VAR7:[%A-Za-z0-9.]+]] = call { i64, i64 } @foo_long 153 // CHECK: extractvalue { i64, i64 } [[VAR7]], 0 154 // CHECK: extractvalue { i64, i64 } [[VAR7]], 1 155 156 long long bar_long_long(void) { 157 return __real__(foo_long_long(2LL - 3LLi)); 158 } 159 160 // CHECK: define{{.*}} i64 @bar_long_long() [[NUW]] { 161 // CHECK: [[VAR8:[%A-Za-z0-9.]+]] = call { i64, i64 } @foo_long_long 162 // CHECK: extractvalue { i64, i64 } [[VAR8]], 0 163 // CHECK: extractvalue { i64, i64 } [[VAR8]], 1 164 165 166 // CHECK: attributes [[NUW]] = { noinline nounwind{{.*}} } 167