Home | History | Annotate | Download | only in CodeGen
      1 // RUN: %clang_cc1 -emit-llvm -o %t %s
      2 // RUN: not grep __builtin %t
      3 // RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-darwin-apple | FileCheck %s
      4 
      5 int printf(const char *, ...);
      6 
      7 void p(char *str, int x) {
      8   printf("%s: %d\n", str, x);
      9 }
     10 void q(char *str, double x) {
     11   printf("%s: %f\n", str, x);
     12 }
     13 void r(char *str, void *ptr) {
     14   printf("%s: %p\n", str, ptr);
     15 }
     16 
     17 int random(void);
     18 
     19 int main() {
     20   int N = random();
     21 #define P(n,args) p(#n #args, __builtin_##n args)
     22 #define Q(n,args) q(#n #args, __builtin_##n args)
     23 #define R(n,args) r(#n #args, __builtin_##n args)
     24 #define V(n,args) p(#n #args, (__builtin_##n args, 0))
     25   P(types_compatible_p, (int, float));
     26   P(choose_expr, (0, 10, 20));
     27   P(constant_p, (sizeof(10)));
     28   P(expect, (N == 12, 0));
     29   V(prefetch, (&N));
     30   V(prefetch, (&N, 1));
     31   V(prefetch, (&N, 1, 0));
     32 
     33   // Numeric Constants
     34 
     35   Q(huge_val, ());
     36   Q(huge_valf, ());
     37   Q(huge_vall, ());
     38   Q(inf, ());
     39   Q(inff, ());
     40   Q(infl, ());
     41 
     42   P(fpclassify, (0, 1, 2, 3, 4, 1.0));
     43   P(fpclassify, (0, 1, 2, 3, 4, 1.0f));
     44   P(fpclassify, (0, 1, 2, 3, 4, 1.0l));
     45   // FIXME:
     46   //  P(isinf_sign, (1.0));
     47 
     48   Q(nan, (""));
     49   Q(nanf, (""));
     50   Q(nanl, (""));
     51   Q(nans, (""));
     52   Q(nan, ("10"));
     53   Q(nanf, ("10"));
     54   Q(nanl, ("10"));
     55   Q(nans, ("10"));
     56 
     57   P(isgreater, (1., 2.));
     58   P(isgreaterequal, (1., 2.));
     59   P(isless, (1., 2.));
     60   P(islessequal, (1., 2.));
     61   P(islessgreater, (1., 2.));
     62   P(isunordered, (1., 2.));
     63 
     64   P(isnan, (1.));
     65 
     66   // Bitwise & Numeric Functions
     67 
     68   P(abs, (N));
     69 
     70   P(clz, (N));
     71   P(clzl, (N));
     72   P(clzll, (N));
     73   P(ctz, (N));
     74   P(ctzl, (N));
     75   P(ctzll, (N));
     76   P(ffs, (N));
     77   P(ffsl, (N));
     78   P(ffsll, (N));
     79   P(parity, (N));
     80   P(parityl, (N));
     81   P(parityll, (N));
     82   P(popcount, (N));
     83   P(popcountl, (N));
     84   P(popcountll, (N));
     85   Q(powi, (1.2f, N));
     86   Q(powif, (1.2f, N));
     87   Q(powil, (1.2f, N));
     88 
     89   // Lib functions
     90   int a, b, n = random(); // Avoid optimizing out.
     91   char s0[10], s1[] = "Hello";
     92   V(strcat, (s0, s1));
     93   V(strcmp, (s0, s1));
     94   V(strncat, (s0, s1, n));
     95   V(strchr, (s0, s1[0]));
     96   V(strrchr, (s0, s1[0]));
     97   V(strcpy, (s0, s1));
     98   V(strncpy, (s0, s1, n));
     99 
    100   // Object size checking
    101   V(__memset_chk, (s0, 0, sizeof s0, n));
    102   V(__memcpy_chk, (s0, s1, sizeof s0, n));
    103   V(__memmove_chk, (s0, s1, sizeof s0, n));
    104   V(__mempcpy_chk, (s0, s1, sizeof s0, n));
    105   V(__strncpy_chk, (s0, s1, sizeof s0, n));
    106   V(__strcpy_chk, (s0, s1, n));
    107   s0[0] = 0;
    108   V(__strcat_chk, (s0, s1, n));
    109   P(object_size, (s0, 0));
    110   P(object_size, (s0, 1));
    111   P(object_size, (s0, 2));
    112   P(object_size, (s0, 3));
    113 
    114   // Whatever
    115 
    116   P(bswap16, (N));
    117   P(bswap32, (N));
    118   P(bswap64, (N));
    119   // FIXME
    120   // V(clear_cache, (&N, &N+1));
    121   V(trap, ());
    122   R(extract_return_addr, (&N));
    123   P(signbit, (1.0));
    124 
    125   return 0;
    126 }
    127 
    128 
    129 
    130 void foo() {
    131  __builtin_strcat(0, 0);
    132 }
    133 
    134 // CHECK-LABEL: define void @bar(
    135 void bar() {
    136   float f;
    137   double d;
    138   long double ld;
    139 
    140   // LLVM's hex representation of float constants is really unfortunate;
    141   // basically it does a float-to-double "conversion" and then prints the
    142   // hex form of that.  That gives us weird artifacts like exponents
    143   // that aren't numerically similar to the original exponent and
    144   // significand bit-patterns that are offset by three bits (because
    145   // the exponent was expanded from 8 bits to 11).
    146   //
    147   // 0xAE98 == 1010111010011000
    148   // 0x15D3 == 1010111010011
    149 
    150   f = __builtin_huge_valf();     // CHECK: float    0x7FF0000000000000
    151   d = __builtin_huge_val();      // CHECK: double   0x7FF0000000000000
    152   ld = __builtin_huge_vall();    // CHECK: x86_fp80 0xK7FFF8000000000000000
    153   f = __builtin_nanf("");        // CHECK: float    0x7FF8000000000000
    154   d = __builtin_nan("");         // CHECK: double   0x7FF8000000000000
    155   ld = __builtin_nanl("");       // CHECK: x86_fp80 0xK7FFFC000000000000000
    156   f = __builtin_nanf("0xAE98");  // CHECK: float    0x7FF815D300000000
    157   d = __builtin_nan("0xAE98");   // CHECK: double   0x7FF800000000AE98
    158   ld = __builtin_nanl("0xAE98"); // CHECK: x86_fp80 0xK7FFFC00000000000AE98
    159   f = __builtin_nansf("");       // CHECK: float    0x7FF4000000000000
    160   d = __builtin_nans("");        // CHECK: double   0x7FF4000000000000
    161   ld = __builtin_nansl("");      // CHECK: x86_fp80 0xK7FFFA000000000000000
    162   f = __builtin_nansf("0xAE98"); // CHECK: float    0x7FF015D300000000
    163   d = __builtin_nans("0xAE98");  // CHECK: double   0x7FF000000000AE98
    164   ld = __builtin_nansl("0xAE98");// CHECK: x86_fp80 0xK7FFF800000000000AE98
    165 
    166 }
    167 // CHECK: }
    168 
    169 
    170 // CHECK-LABEL: define void @test_float_builtins
    171 void test_float_builtins(float F, double D, long double LD) {
    172   volatile int res;
    173   res = __builtin_isinf(F);
    174   // CHECK:  call float @fabsf(float
    175   // CHECK:  fcmp oeq float {{.*}}, 0x7FF0000000000000
    176 
    177   res = __builtin_isinf(D);
    178   // CHECK:  call double @fabs(double
    179   // CHECK:  fcmp oeq double {{.*}}, 0x7FF0000000000000
    180 
    181   res = __builtin_isinf(LD);
    182   // CHECK:  call x86_fp80 @fabsl(x86_fp80
    183   // CHECK:  fcmp oeq x86_fp80 {{.*}}, 0xK7FFF8000000000000000
    184 
    185   res = __builtin_isfinite(F);
    186   // CHECK: fcmp oeq float
    187   // CHECK: call float @fabsf
    188   // CHECK: fcmp une float {{.*}}, 0x7FF0000000000000
    189   // CHECK: and i1
    190 
    191   res = __builtin_isnormal(F);
    192   // CHECK: fcmp oeq float
    193   // CHECK: call float @fabsf
    194   // CHECK: fcmp ult float {{.*}}, 0x7FF0000000000000
    195   // CHECK: fcmp uge float {{.*}}, 0x3810000000000000
    196   // CHECK: and i1
    197   // CHECK: and i1
    198 }
    199 
    200 // CHECK-LABEL: define void @test_builtin_longjmp
    201 void test_builtin_longjmp(void **buffer) {
    202   // CHECK: [[BITCAST:%.*]] = bitcast
    203   // CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(i8* [[BITCAST]])
    204   __builtin_longjmp(buffer, 1);
    205   // CHECK-NEXT: unreachable
    206 }
    207 
    208 // CHECK-LABEL: define i64 @test_builtin_readcyclecounter
    209 long long test_builtin_readcyclecounter() {
    210   // CHECK: call i64 @llvm.readcyclecounter()
    211   return __builtin_readcyclecounter();
    212 }
    213