Home | History | Annotate | Download | only in CodeGenCXX 
      1 // RUN: %clang_cc1 -triple x86_64-linux -fblocks -emit-llvm -o - %s -std=c++1y | FileCheck %s
      2 
      3 // CHECK: @"_ZZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEvE2l2" =
      4 // CHECK: internal global i32* @"_ZZNK17pr18020_constexpr3$_1clEvE2l1"
      5 // CHECK: @_ZZL14deduced_returnvE1n = internal global i32 42
      6 // CHECK: @_ZZZL20block_deduced_returnvEUb_E1n = internal global i32 42
      7 // CHECK: @_ZZ18static_local_labelPvE1q = linkonce_odr global i8* blockaddress(@_Z18static_local_labelPv, %{{.*}})
      8 // CHECK: @"_ZZNK3$_2clEvE1x" = internal global i32 42
      9 
     10 namespace pr6769 {
     11 struct X {
     12   static void f();
     13 };
     14 
     15 void X::f() {
     16   static int *i;
     17   {
     18     struct Y {
     19       static void g() {
     20         i = new int();
     21 	*i = 100;
     22 	(*i) = (*i) +1;
     23       }
     24     };
     25     (void)Y::g();
     26   }
     27   (void)i;
     28 }
     29 }
     30 
     31 namespace pr7101 {
     32 void foo() {
     33     static int n = 0;
     34     struct Helper {
     35         static void Execute() {
     36             n++;
     37         }
     38     };
     39     Helper::Execute();
     40 }
     41 }
     42 
     43 // These tests all break the assumption that the static var decl has to be
     44 // emitted before use of the var decl.  This happens because we defer emission
     45 // of variables with internal linkage and no initialization side effects, such
     46 // as 'x'.  Then we hit operator()() in 'f', and emit the callee before we emit
     47 // the arguments, so we emit the innermost function first.
     48 
     49 namespace pr18020_lambda {
     50 // Referring to l1 before emitting it used to crash.
     51 auto x = []() {
     52   static int l1 = 0;
     53   return [] { return l1; };
     54 };
     55 int f() { return x()(); }
     56 }
     57 
     58 // CHECK-LABEL: define internal i32 @"_ZZNK14pr18020_lambda3$_0clEvENKUlvE_clEv"
     59 // CHECK: load i32, i32* @"_ZZNK14pr18020_lambda3$_0clEvE2l1"
     60 
     61 namespace pr18020_constexpr {
     62 // Taking the address of l1 in a constant expression used to crash.
     63 auto x = []() {
     64   static int l1 = 0;
     65   return [] {
     66     static int *l2 = &l1;
     67     return *l2;
     68   };
     69 };
     70 int f() { return x()(); }
     71 }
     72 
     73 // CHECK-LABEL: define internal i32 @"_ZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEv"
     74 // CHECK: load i32*, i32** @"_ZZZNK17pr18020_constexpr3$_1clEvENKUlvE_clEvE2l2"
     75 
     76 // Lambda-less reduction that references l1 before emitting it.  This didn't
     77 // crash if you put it in a namespace.
     78 struct pr18020_class {
     79   auto operator()() {
     80     static int l1 = 0;
     81     struct U {
     82       int operator()() { return l1; }
     83     };
     84     return U();
     85   }
     86 };
     87 static pr18020_class x;
     88 int pr18020_f() { return x()(); }
     89 
     90 // CHECK-LABEL: define linkonce_odr i32 @_ZZN13pr18020_classclEvEN1UclEv
     91 // CHECK: load i32, i32* @_ZZN13pr18020_classclEvE2l1
     92 
     93 // In this test case, the function containing the static local will not be
     94 // emitted because it is unneeded. However, the operator call of the inner class
     95 // is called, and the static local is referenced and must be emitted.
     96 static auto deduced_return() {
     97   static int n = 42;
     98   struct S { int *operator()() { return &n; } };
     99   return S();
    100 }
    101 extern "C" int call_deduced_return_operator() {
    102   return *decltype(deduced_return())()();
    103 }
    104 
    105 // CHECK-LABEL: define i32 @call_deduced_return_operator()
    106 // CHECK: call i32* @_ZZL14deduced_returnvEN1SclEv(
    107 // CHECK: load i32, i32* %
    108 // CHECK: ret i32 %
    109 
    110 // CHECK-LABEL: define internal i32* @_ZZL14deduced_returnvEN1SclEv(%struct.S* %this)
    111 // CHECK: ret i32* @_ZZL14deduced_returnvE1n
    112 
    113 static auto block_deduced_return() {
    114   auto (^b)() = ^() {
    115     static int n = 42;
    116     struct S { int *operator()() { return &n; } };
    117     return S();
    118   };
    119   return b();
    120 }
    121 extern "C" int call_block_deduced_return() {
    122   return *decltype(block_deduced_return())()();
    123 }
    124 
    125 // CHECK-LABEL: define i32 @call_block_deduced_return()
    126 // CHECK: call i32* @_ZZZL20block_deduced_returnvEUb_EN1SclEv(
    127 // CHECK: load i32, i32* %
    128 // CHECK: ret i32 %
    129 
    130 // CHECK-LABEL: define internal i32* @_ZZZL20block_deduced_returnvEUb_EN1SclEv(%struct.S.6* %this) #0 align 2 {
    131 // CHECK: ret i32* @_ZZZL20block_deduced_returnvEUb_E1n
    132 
    133 inline auto static_local_label(void *p) {
    134   if (p)
    135     goto *p;
    136   static void *q = &&label;
    137   struct S { static void *get() { return q; } };
    138   return S();
    139 label:
    140   __builtin_abort();
    141 }
    142 void *global_label = decltype(static_local_label(0))::get();
    143 
    144 // CHECK-LABEL: define linkonce_odr i8* @_ZZ18static_local_labelPvEN1S3getEv()
    145 // CHECK: %[[lbl:[^ ]*]] = load i8*, i8** @_ZZ18static_local_labelPvE1q
    146 // CHECK: ret i8* %[[lbl]]
    147 
    148 auto global_lambda = []() {
    149   static int x = 42;
    150   struct S { static int *get() { return &x; } };
    151   return S();
    152 };
    153 extern "C" int use_global_lambda() {
    154   return *decltype(global_lambda())::get();
    155 }
    156 // CHECK-LABEL: define i32 @use_global_lambda()
    157 // CHECK: call i32* @"_ZZNK3$_2clEvEN1S3getEv"()
    158 
    159 // CHECK-LABEL: define internal i32* @"_ZZNK3$_2clEvEN1S3getEv"()
    160 // CHECK: ret i32* @"_ZZNK3$_2clEvE1x"
    161