clang/test/CodeGen/math-builtins-long.c

   1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -w -S -o - -emit-llvm %s \
   2 // RUN:   -fmath-errno | FileCheck %s -check-prefix=F80
   3 // RUN: %clang_cc1 -triple ppc64le-unknown-unknown -w -S -o - -emit-llvm %s \
   4 // RUN:   -fmath-errno | FileCheck %s -check-prefix=PPC
   5 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -mlong-double-128 -w -S \
   6 // RUN:   -o - -emit-llvm %s -fmath-errno | FileCheck %s -check-prefix=X86F128
   7 // RUN: %clang_cc1 -triple ppc64le-unknown-unknown -mabi=ieeelongdouble -w -S \
   8 // RUN:   -o - -emit-llvm %s -fmath-errno | FileCheck %s -check-prefix=PPCF128
   9
  10 void bar(long double);
  11
  12 void foo(long double f, long double *l, int *i, const char *c) {
  13   // F80: call x86_fp80 @fmodl(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
  14   // PPC: call ppc_fp128 @fmodl(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
  15   // X86F128: call fp128 @fmodl(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
  16   // PPCF128: call fp128 @fmodf128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
  17   __builtin_fmodl(f,f);
  18
  19   // F80: call x86_fp80 @atan2l(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
  20   // PPC: call ppc_fp128 @atan2l(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
  21   // X86F128: call fp128 @atan2l(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
  22   // PPCF128: call fp128 @atan2f128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
  23   __builtin_atan2l(f,f);
  24
  25   // F80: call x86_fp80 @llvm.copysign.f80(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
  26   // PPC: call ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
  27   // X86F128: call fp128 @llvm.copysign.f128(fp128 %{{.+}}, fp128 %{{.+}})
  28   // PPCF128: call fp128 @llvm.copysign.f128(fp128 %{{.+}}, fp128 %{{.+}})
  29   __builtin_copysignl(f,f);
  30
  31   // F80: call x86_fp80 @llvm.fabs.f80(x86_fp80 %{{.+}})
  32   // PPC: call ppc_fp128 @llvm.fabs.ppcf128(ppc_fp128 %{{.+}})
  33   // X86F128: call fp128 @llvm.fabs.f128(fp128 %{{.+}})
  34   // PPCF128: call fp128 @llvm.fabs.f128(fp128 %{{.+}})
  35   __builtin_fabsl(f);
  36
  37   // F80: call { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80 %{{.+}})
  38   // PPC: call { ppc_fp128, i32 } @llvm.frexp.ppcf128.i32(ppc_fp128 %{{.+}})
  39   // X86F128: call { fp128, i32 } @llvm.frexp.f128.i32(fp128 %{{.+}})
  40   // PPCF128: call { fp128, i32 } @llvm.frexp.f128.i32(fp128 %{{.+}})
  41   __builtin_frexpl(f,i);
  42
  43   // F80: store x86_fp80 0xK7FFF8000000000000000, ptr
  44   // PPC: store ppc_fp128 0xM7FF00000000000000000000000000000, ptr
  45   // X86F128: store fp128 0xL00000000000000007FFF000000000000, ptr
  46   // PPCF128: store fp128 0xL00000000000000007FFF000000000000, ptr
  47   *l = __builtin_huge_vall();
  48
  49   // F80: store x86_fp80 0xK7FFF8000000000000000, ptr
  50   // PPC: store ppc_fp128 0xM7FF00000000000000000000000000000, ptr
  51   // X86F128: store fp128 0xL00000000000000007FFF000000000000, ptr
  52   // PPCF128: store fp128 0xL00000000000000007FFF000000000000, ptr
  53   *l = __builtin_infl();
  54
  55   // F80: call x86_fp80 @ldexpl(x86_fp80 noundef %{{.+}}, i32 noundef %{{.+}})
  56   // PPC: call ppc_fp128 @ldexpl(ppc_fp128 noundef %{{.+}}, {{(signext)?.+}})
  57   // X86F128: call fp128 @ldexpl(fp128 noundef %{{.+}}, {{(signext)?.+}})
  58   // PPCF128: call fp128 @ldexpf128(fp128 noundef %{{.+}}, {{(signext)?.+}})
  59   __builtin_ldexpl(f,f);
  60
  61   // F80: call x86_fp80 @modfl(x86_fp80 noundef %{{.+}}, ptr noundef %{{.+}})
  62   // PPC: call ppc_fp128 @modfl(ppc_fp128 noundef %{{.+}}, ptr noundef %{{.+}})
  63   // X86F128: call fp128 @modfl(fp128 noundef %{{.+}}, ptr noundef %{{.+}})
  64   // PPCF128: call fp128 @modff128(fp128 noundef %{{.+}}, ptr noundef %{{.+}})
  65   __builtin_modfl(f,l);
  66
  67   // F80: call x86_fp80 @nanl(ptr noundef %{{.+}})
  68   // PPC: call ppc_fp128 @nanl(ptr noundef %{{.+}})
  69   // X86F128: call fp128 @nanl(ptr noundef %{{.+}})
  70   // PPCF128: call fp128 @nanf128(ptr noundef %{{.+}})
  71   __builtin_nanl(c);
  72
  73   // F80: call x86_fp80 @nansl(ptr noundef %{{.+}})
  74   // PPC: call ppc_fp128 @nansl(ptr noundef %{{.+}})
  75   // X86F128: call fp128 @nansl(ptr noundef %{{.+}})
  76   // PPCF128: call fp128 @nansf128(ptr noundef %{{.+}})
  77   __builtin_nansl(c);
  78
  79   // F80: call x86_fp80 @powl(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
  80   // PPC: call ppc_fp128 @powl(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
  81   // X86F128: call fp128 @powl(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
  82   // PPCF128: call fp128 @powf128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
  83   __builtin_powl(f,f);
  84
  85   // F80: call x86_fp80 @acosl(x86_fp80 noundef %{{.+}})
  86   // PPC: call ppc_fp128 @acosl(ppc_fp128 noundef %{{.+}})
  87   // X86F128: call fp128 @acosl(fp128 noundef %{{.+}})
  88   // PPCF128: call fp128 @acosf128(fp128 noundef %{{.+}})
  89   __builtin_acosl(f);
  90
  91   // F80: call x86_fp80 @acoshl(x86_fp80 noundef %{{.+}})
  92   // PPC: call ppc_fp128 @acoshl(ppc_fp128 noundef %{{.+}})
  93   // X86F128: call fp128 @acoshl(fp128 noundef %{{.+}})
  94   // PPCF128: call fp128 @acoshf128(fp128 noundef %{{.+}})
  95   __builtin_acoshl(f);
  96
  97   // F80: call x86_fp80 @asinl(x86_fp80 noundef %{{.+}})
  98   // PPC: call ppc_fp128 @asinl(ppc_fp128 noundef %{{.+}})
  99   // X86F128: call fp128 @asinl(fp128 noundef %{{.+}})
 100   // PPCF128: call fp128 @asinf128(fp128 noundef %{{.+}})
 101   __builtin_asinl(f);
 102
 103   // F80: call x86_fp80 @asinhl(x86_fp80 noundef %{{.+}})
 104   // PPC: call ppc_fp128 @asinhl(ppc_fp128 noundef %{{.+}})
 105   // X86F128: call fp128 @asinhl(fp128 noundef %{{.+}})
 106   // PPCF128: call fp128 @asinhf128(fp128 noundef %{{.+}})
 107   __builtin_asinhl(f);
 108
 109   // F80: call x86_fp80 @atanl(x86_fp80 noundef %{{.+}})
 110   // PPC: call ppc_fp128 @atanl(ppc_fp128 noundef %{{.+}})
 111   // X86F128: call fp128 @atanl(fp128 noundef %{{.+}})
 112   // PPCF128: call fp128 @atanf128(fp128 noundef %{{.+}})
 113   __builtin_atanl(f);
 114
 115   // F80: call x86_fp80 @atanhl(x86_fp80 noundef %{{.+}})
 116   // PPC: call ppc_fp128 @atanhl(ppc_fp128 noundef %{{.+}})
 117   // X86F128: call fp128 @atanhl(fp128 noundef %{{.+}})
 118   // PPCF128: call fp128 @atanhf128(fp128 noundef %{{.+}})
 119   __builtin_atanhl(f);
 120
 121   // F80: call x86_fp80 @cbrtl(x86_fp80 noundef %{{.+}})
 122   // PPC: call ppc_fp128 @cbrtl(ppc_fp128 noundef %{{.+}})
 123   // X86F128: call fp128 @cbrtl(fp128 noundef %{{.+}})
 124   // PPCF128: call fp128 @cbrtf128(fp128 noundef %{{.+}})
 125   __builtin_cbrtl(f);
 126
 127   // F80: call x86_fp80 @llvm.ceil.f80(x86_fp80 %{{.+}})
 128   // PPC: call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %{{.+}})
 129   // X86F128: call fp128 @llvm.ceil.f128(fp128 %{{.+}})
 130   // PPCF128: call fp128 @llvm.ceil.f128(fp128 %{{.+}})
 131   __builtin_ceill(f);
 132
 133   // F80: call x86_fp80 @cosl(x86_fp80 noundef %{{.+}})
 134   // PPC: call ppc_fp128 @cosl(ppc_fp128 noundef %{{.+}})
 135   // X86F128: call fp128 @cosl(fp128 noundef %{{.+}})
 136   // PPCF128: call fp128 @cosf128(fp128 noundef %{{.+}})
 137   __builtin_cosl(f);
 138
 139   // F80: call x86_fp80 @coshl(x86_fp80 noundef %{{.+}})
 140   // PPC: call ppc_fp128 @coshl(ppc_fp128 noundef %{{.+}})
 141   // X86F128: call fp128 @coshl(fp128 noundef %{{.+}})
 142   // PPCF128: call fp128 @coshf128(fp128 noundef %{{.+}})
 143   __builtin_coshl(f);
 144
 145   // F80: call x86_fp80 @llvm.floor.f80(x86_fp80 %{{.+}})
 146   // PPC: call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %{{.+}})
 147   // X86F128: call fp128 @llvm.floor.f128(fp128 %{{.+}})
 148   // PPCF128: call fp128 @llvm.floor.f128(fp128 %{{.+}})
 149   __builtin_floorl(f);
 150
 151   // F80: call x86_fp80 @llvm.maxnum.f80(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
 152   // PPC: call ppc_fp128 @llvm.maxnum.ppcf128(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
 153   // X86F128: call fp128 @llvm.maxnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
 154   // PPCF128: call fp128 @llvm.maxnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
 155   __builtin_fmaxl(f,f);
 156
 157   // F80: call x86_fp80 @llvm.minnum.f80(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
 158   // PPC: call ppc_fp128 @llvm.minnum.ppcf128(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
 159   // X86F128: call fp128 @llvm.minnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
 160   // PPCF128: call fp128 @llvm.minnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
 161   __builtin_fminl(f,f);
 162
 163   // F80: call x86_fp80 @llvm.nearbyint.f80(x86_fp80 %{{.+}})
 164   // PPC: call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %{{.+}})
 165   // X86F128: call fp128 @llvm.nearbyint.f128(fp128 %{{.+}})
 166   // PPCF128: call fp128 @llvm.nearbyint.f128(fp128 %{{.+}})
 167   __builtin_nearbyintl(f);
 168
 169   // F80: call x86_fp80 @llvm.trunc.f80(x86_fp80 %{{.+}})
 170   // PPC: call ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128  %{{.+}})
 171   // X86F128: call fp128 @llvm.trunc.f128(fp128 %{{.+}})
 172   // PPCF128: call fp128 @llvm.trunc.f128(fp128 %{{.+}})
 173   __builtin_truncl(f);
 174
 175   // F80: call x86_fp80 @llvm.rint.f80(x86_fp80 %{{.+}})
 176   // PPC: call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %{{.+}})
 177   // X86F128: call fp128 @llvm.rint.f128(fp128 %{{.+}})
 178   // PPCF128: call fp128 @llvm.rint.f128(fp128 %{{.+}})
 179   __builtin_rintl(f);
 180
 181   // F80: call x86_fp80 @llvm.round.f80(x86_fp80 %{{.+}})
 182   // PPC: call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %{{.+}})
 183   // X86F128: call fp128 @llvm.round.f128(fp128 %{{.+}})
 184   // PPCF128: call fp128 @llvm.round.f128(fp128 %{{.+}})
 185   __builtin_roundl(f);
 186
 187   // F80: call x86_fp80 @erfl(x86_fp80 noundef %{{.+}})
 188   // PPC: call ppc_fp128 @erfl(ppc_fp128 noundef %{{.+}})
 189   // X86F128: call fp128 @erfl(fp128 noundef %{{.+}})
 190   // PPCF128: call fp128 @erff128(fp128 noundef %{{.+}})
 191   __builtin_erfl(f);
 192
 193   // F80: call x86_fp80 @erfcl(x86_fp80 noundef %{{.+}})
 194   // PPC: call ppc_fp128 @erfcl(ppc_fp128 noundef %{{.+}})
 195   // X86F128: call fp128 @erfcl(fp128 noundef %{{.+}})
 196   // PPCF128: call fp128 @erfcf128(fp128 noundef %{{.+}})
 197   __builtin_erfcl(f);
 198
 199   // F80: call x86_fp80 @expl(x86_fp80 noundef %{{.+}})
 200   // PPC: call ppc_fp128 @expl(ppc_fp128 noundef %{{.+}})
 201   // X86F128: call fp128 @expl(fp128 noundef %{{.+}})
 202   // PPCF128: call fp128 @expf128(fp128 noundef %{{.+}})
 203   __builtin_expl(f);
 204
 205   // F80: call x86_fp80 @exp2l(x86_fp80 noundef %{{.+}})
 206   // PPC: call ppc_fp128 @exp2l(ppc_fp128 noundef %{{.+}})
 207   // X86F128: call fp128 @exp2l(fp128 noundef %{{.+}})
 208   // PPCF128: call fp128 @exp2f128(fp128 noundef %{{.+}})
 209   __builtin_exp2l(f);
 210
 211   // F80: call x86_fp80 @expm1l(x86_fp80 noundef %{{.+}})
 212   // PPC: call ppc_fp128 @expm1l(ppc_fp128 noundef %{{.+}})
 213   // X86F128: call fp128 @expm1l(fp128 noundef %{{.+}})
 214   // PPCF128: call fp128 @expm1f128(fp128 noundef %{{.+}})
 215   __builtin_expm1l(f);
 216
 217   // F80: call x86_fp80 @fdiml(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
 218   // PPC: call ppc_fp128 @fdiml(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
 219   // X86F128: call fp128 @fdiml(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 220   // PPCF128: call fp128 @fdimf128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 221   __builtin_fdiml(f,f);
 222
 223   // F80: call x86_fp80 @fmal(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
 224   // PPC: call ppc_fp128 @fmal(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
 225   // X86F128: call fp128 @fmal(fp128 noundef %{{.+}}, fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 226   // PPCF128: call fp128 @fmaf128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 227   __builtin_fmal(f,f,f);
 228
 229   // F80: call x86_fp80 @hypotl(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
 230   // PPC: call ppc_fp128 @hypotl(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
 231   // X86F128: call fp128 @hypotl(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 232   // PPCF128: call fp128 @hypotf128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 233   __builtin_hypotl(f,f);
 234
 235   // F80: call i32 @ilogbl(x86_fp80 noundef %{{.+}})
 236   // PPC: call {{(i32)|(signext i32)}} @ilogbl(ppc_fp128 noundef %{{.+}})
 237   // X86F128: call {{(i32)|(signext i32)}} @ilogbl(fp128 noundef %{{.+}})
 238   // PPCF128: call {{(i32)|(signext i32)}} @ilogbf128(fp128 noundef %{{.+}})
 239   __builtin_ilogbl(f);
 240
 241   // F80: call x86_fp80 @lgammal(x86_fp80 noundef %{{.+}})
 242   // PPC: call ppc_fp128 @lgammal(ppc_fp128 noundef %{{.+}})
 243   // X86F128: call fp128 @lgammal(fp128 noundef %{{.+}})
 244   // PPCF128: call fp128 @lgammaf128(fp128 noundef %{{.+}})
 245   __builtin_lgammal(f);
 246
 247   // F80: call i64 @llrintl(x86_fp80 noundef %{{.+}})
 248   // PPC: call i64 @llrintl(ppc_fp128 noundef %{{.+}})
 249   // X86F128: call i64 @llrintl(fp128 noundef %{{.+}})
 250   // PPCF128: call i64 @llrintf128(fp128 noundef %{{.+}})
 251   __builtin_llrintl(f);
 252
 253   // F80: call i64 @llroundl(x86_fp80 noundef %{{.+}})
 254   // PPC: call i64 @llroundl(ppc_fp128 noundef %{{.+}})
 255   // X86F128: call i64 @llroundl(fp128 noundef %{{.+}})
 256   // PPCF128: call i64 @llroundf128(fp128 noundef %{{.+}})
 257   __builtin_llroundl(f);
 258
 259   // F80: call x86_fp80 @logl(x86_fp80 noundef %{{.+}})
 260   // PPC: call ppc_fp128 @logl(ppc_fp128 noundef %{{.+}})
 261   // X86F128: call fp128 @logl(fp128 noundef %{{.+}})
 262   // PPCF128: call fp128 @logf128(fp128 noundef %{{.+}})
 263   __builtin_logl(f);
 264
 265   // F80: call x86_fp80 @log10l(x86_fp80 noundef %{{.+}})
 266   // PPC: call ppc_fp128 @log10l(ppc_fp128 noundef %{{.+}})
 267   // X86F128: call fp128 @log10l(fp128 noundef %{{.+}})
 268   // PPCF128: call fp128 @log10f128(fp128 noundef %{{.+}})
 269   __builtin_log10l(f);
 270
 271   // F80: call x86_fp80 @log1pl(x86_fp80 noundef %{{.+}})
 272   // PPC: call ppc_fp128 @log1pl(ppc_fp128 noundef %{{.+}})
 273   // X86F128: call fp128 @log1pl(fp128 noundef %{{.+}})
 274   // PPCF128: call fp128 @log1pf128(fp128 noundef %{{.+}})
 275   __builtin_log1pl(f);
 276
 277   // F80: call x86_fp80 @log2l(x86_fp80 noundef %{{.+}})
 278   // PPC: call ppc_fp128 @log2l(ppc_fp128 noundef %{{.+}})
 279   // X86F128: call fp128 @log2l(fp128 noundef %{{.+}})
 280   // PPCF128: call fp128 @log2f128(fp128 noundef %{{.+}})
 281   __builtin_log2l(f);
 282
 283   // F80: call x86_fp80 @logbl(x86_fp80 noundef %{{.+}})
 284   // PPC: call ppc_fp128 @logbl(ppc_fp128 noundef %{{.+}})
 285   // X86F128: call fp128 @logbl(fp128 noundef %{{.+}})
 286   // PPCF128: call fp128 @logbf128(fp128 noundef %{{.+}})
 287   __builtin_logbl(f);
 288
 289   // F80: call i64 @lrintl(x86_fp80 noundef %{{.+}})
 290   // PPC: call i64 @lrintl(ppc_fp128 noundef %{{.+}})
 291   // X86F128: call i64 @lrintl(fp128 noundef %{{.+}})
 292   // PPCF128: call i64 @lrintf128(fp128 noundef %{{.+}})
 293   __builtin_lrintl(f);
 294
 295   // F80: call i64 @lroundl(x86_fp80 noundef %{{.+}})
 296   // PPC: call i64 @lroundl(ppc_fp128 noundef %{{.+}})
 297   // X86F128: call i64 @lroundl(fp128 noundef %{{.+}})
 298   // PPCF128: call i64 @lroundf128(fp128 noundef %{{.+}})
 299   __builtin_lroundl(f);
 300
 301   // F80: call x86_fp80 @nextafterl(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
 302   // PPC: call ppc_fp128 @nextafterl(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
 303   // X86F128: call fp128 @nextafterl(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 304   // PPCF128: call fp128 @nextafterf128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 305   __builtin_nextafterl(f,f);
 306
 307   // F80: call x86_fp80 @nexttowardl(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
 308   // PPC: call ppc_fp128 @nexttowardl(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
 309   // X86F128: call fp128 @nexttowardl(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 310   // PPCF128: call fp128 @__nexttowardieee128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 311   __builtin_nexttowardl(f,f);
 312
 313   // F80: call x86_fp80 @remainderl(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}})
 314   // PPC: call ppc_fp128 @remainderl(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}})
 315   // X86F128: call fp128 @remainderl(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 316   // PPCF128: call fp128 @remainderf128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}})
 317   __builtin_remainderl(f,f);
 318
 319   // F80: call x86_fp80 @remquol(x86_fp80 noundef %{{.+}}, x86_fp80 noundef %{{.+}}, ptr noundef %{{.+}})
 320   // PPC: call ppc_fp128 @remquol(ppc_fp128 noundef %{{.+}}, ppc_fp128 noundef %{{.+}}, ptr noundef %{{.+}})
 321   // X86F128: call fp128 @remquol(fp128 noundef %{{.+}}, fp128 noundef %{{.+}}, ptr noundef %{{.+}})
 322   // PPCF128: call fp128 @remquof128(fp128 noundef %{{.+}}, fp128 noundef %{{.+}}, ptr noundef %{{.+}})
 323   __builtin_remquol(f,f,i);
 324
 325   // F80: call x86_fp80 @scalblnl(x86_fp80 noundef %{{.+}}, i64 noundef %{{.+}})
 326   // PPC: call ppc_fp128 @scalblnl(ppc_fp128 noundef %{{.+}}, i64 noundef %{{.+}})
 327   // X86F128: call fp128 @scalblnl(fp128 noundef %{{.+}}, i64 noundef %{{.+}})
 328   // PPCF128: call fp128 @scalblnf128(fp128 noundef %{{.+}}, i64 noundef %{{.+}})
 329   __builtin_scalblnl(f,f);
 330
 331   // F80: call x86_fp80 @scalbnl(x86_fp80 noundef %{{.+}}, i32 noundef %{{.+}})
 332   // PPC: call ppc_fp128 @scalbnl(ppc_fp128 noundef %{{.+}}, {{(signext)?.+}})
 333   // X86F128: call fp128 @scalbnl(fp128 noundef %{{.+}}, {{(signext)?.+}})
 334   // PPCF128: call fp128 @scalbnf128(fp128 noundef %{{.+}}, {{(signext)?.+}})
 335   __builtin_scalbnl(f,f);
 336
 337   // F80: call x86_fp80 @sinl(x86_fp80 noundef %{{.+}})
 338   // PPC: call ppc_fp128 @sinl(ppc_fp128 noundef %{{.+}})
 339   // X86F128: call fp128 @sinl(fp128 noundef %{{.+}})
 340   // PPCF128: call fp128 @sinf128(fp128 noundef %{{.+}})
 341   __builtin_sinl(f);
 342
 343   // F80: call x86_fp80 @sinhl(x86_fp80 noundef %{{.+}})
 344   // PPC: call ppc_fp128 @sinhl(ppc_fp128 noundef %{{.+}})
 345   // X86F128: call fp128 @sinhl(fp128 noundef %{{.+}})
 346   // PPCF128: call fp128 @sinhf128(fp128 noundef %{{.+}})
 347   __builtin_sinhl(f);
 348
 349   // F80: call x86_fp80 @sqrtl(x86_fp80 noundef %{{.+}})
 350   // PPC: call ppc_fp128 @sqrtl(ppc_fp128 noundef %{{.+}})
 351   // X86F128: call fp128 @sqrtl(fp128 noundef %{{.+}})
 352   // PPCF128: call fp128 @sqrtf128(fp128 noundef %{{.+}})
 353   __builtin_sqrtl(f);
 354
 355   // F80: call x86_fp80 @tanl(x86_fp80 noundef %{{.+}})
 356   // PPC: call ppc_fp128 @tanl(ppc_fp128 noundef %{{.+}})
 357   // X86F128: call fp128 @tanl(fp128 noundef %{{.+}})
 358   // PPCF128: call fp128 @tanf128(fp128 noundef %{{.+}})
 359   __builtin_tanl(f);
 360
 361   // F80: call x86_fp80 @tanhl(x86_fp80 noundef %{{.+}})
 362   // PPC: call ppc_fp128 @tanhl(ppc_fp128 noundef %{{.+}})
 363   // X86F128: call fp128 @tanhl(fp128 noundef %{{.+}})
 364   // PPCF128: call fp128 @tanhf128(fp128 noundef %{{.+}})
 365   __builtin_tanhl(f);
 366
 367   // F80: call x86_fp80 @tgammal(x86_fp80 noundef %{{.+}})
 368   // PPC: call ppc_fp128 @tgammal(ppc_fp128 noundef %{{.+}})
 369   // X86F128: call fp128 @tgammal(fp128 noundef %{{.+}})
 370   // PPCF128: call fp128 @tgammaf128(fp128 noundef %{{.+}})
 371   __builtin_tgammal(f);
 372 }