clang/test/CodeGen/PowerPC/ppc64-complex-return.c

   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{{.*}} }