1 // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -O1 -o - %s | FileCheck %s 2 // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -O1 -fcxx-exceptions -fexceptions -o - %s | FileCheck --check-prefix=CHECK-EH %s 3 4 // Test code generation for the named return value optimization. 5 class X { 6 public: 7 X(); 8 X(const X&); 9 ~X(); 10 }; 11 12 template<typename T> struct Y { 13 Y(); 14 static Y f() { 15 Y y; 16 return y; 17 } 18 }; 19 20 // CHECK-LABEL: define void @_Z5test0v 21 // CHECK-EH-LABEL: define void @_Z5test0v 22 X test0() { 23 X x; 24 // CHECK: call {{.*}} @_ZN1XC1Ev 25 // CHECK-NEXT: ret void 26 27 // CHECK-EH: call {{.*}} @_ZN1XC1Ev 28 // CHECK-EH-NEXT: ret void 29 return x; 30 } 31 32 // CHECK-LABEL: define void @_Z5test1b( 33 // CHECK-EH-LABEL: define void @_Z5test1b( 34 X test1(bool B) { 35 // CHECK: tail call {{.*}} @_ZN1XC1Ev 36 // CHECK-NEXT: ret void 37 X x; 38 if (B) 39 return (x); 40 return x; 41 // CHECK-EH: tail call {{.*}} @_ZN1XC1Ev 42 // CHECK-EH-NEXT: ret void 43 } 44 45 // CHECK-LABEL: define void @_Z5test2b 46 // CHECK-EH-LABEL: define void @_Z5test2b 47 // CHECK-EH-SAME: personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) 48 X test2(bool B) { 49 // No NRVO. 50 51 X x; 52 X y; 53 if (B) 54 return y; 55 return x; 56 57 // CHECK: call {{.*}} @_ZN1XC1Ev 58 // CHECK-NEXT: {{.*}} getelementptr inbounds %class.X, %class.X* %y, i32 0, i32 0 59 // CHECK-NEXT: call void @llvm.lifetime.start 60 // CHECK-NEXT: call {{.*}} @_ZN1XC1Ev 61 // CHECK: call {{.*}} @_ZN1XC1ERKS_ 62 // CHECK: call {{.*}} @_ZN1XC1ERKS_ 63 // CHECK: call {{.*}} @_ZN1XD1Ev 64 // CHECK-NEXT: call void @llvm.lifetime.end 65 // CHECK: call {{.*}} @_ZN1XD1Ev 66 // CHECK-NEXT: call void @llvm.lifetime.end 67 // CHECK: ret void 68 69 // The block ordering in the -fexceptions IR is unfortunate. 70 71 // CHECK-EH: call void @llvm.lifetime.start 72 // CHECK-EH-NEXT: call {{.*}} @_ZN1XC1Ev 73 // CHECK-EH: call void @llvm.lifetime.start 74 // CHECK-EH-NEXT: invoke {{.*}} @_ZN1XC1Ev 75 // -> %invoke.cont, %lpad 76 77 // %invoke.cont: 78 // CHECK-EH: br i1 79 // -> %if.then, %if.end 80 81 // %if.then: returning 'x' 82 // CHECK-EH: invoke {{.*}} @_ZN1XC1ERKS_ 83 // -> %cleanup, %lpad1 84 85 // %lpad: landing pad for ctor of 'y', dtor of 'y' 86 // CHECK-EH: [[CAUGHTVAL:%.*]] = landingpad { i8*, i32 } 87 // CHECK-EH-NEXT: cleanup 88 // CHECK-EH-NEXT: extractvalue { i8*, i32 } [[CAUGHTVAL]], 0 89 // CHECK-EH-NEXT: extractvalue { i8*, i32 } [[CAUGHTVAL]], 1 90 // CHECK-EH-NEXT: br label 91 // -> %eh.cleanup 92 93 // %lpad1: landing pad for return copy ctors, EH cleanup for 'y' 94 // CHECK-EH: invoke {{.*}} @_ZN1XD1Ev 95 // -> %eh.cleanup, %terminate.lpad 96 97 // %if.end: returning 'y' 98 // CHECK-EH: invoke {{.*}} @_ZN1XC1ERKS_ 99 // -> %cleanup, %lpad1 100 101 // %cleanup: normal cleanup for 'y' 102 // CHECK-EH: invoke {{.*}} @_ZN1XD1Ev 103 // -> %invoke.cont11, %lpad 104 105 // %invoke.cont11: normal cleanup for 'x' 106 // CHECK-EH: call void @llvm.lifetime.end 107 // CHECK-EH-NEXT: call {{.*}} @_ZN1XD1Ev 108 // CHECK-EH-NEXT: call void @llvm.lifetime.end 109 // CHECK-EH-NEXT: ret void 110 111 // %eh.cleanup: EH cleanup for 'x' 112 // CHECK-EH: invoke {{.*}} @_ZN1XD1Ev 113 // -> %invoke.cont17, %terminate.lpad 114 115 // %invoke.cont17: rethrow block for %eh.cleanup. 116 // This really should be elsewhere in the function. 117 // CHECK-EH: resume { i8*, i32 } 118 119 // %terminate.lpad: terminate landing pad. 120 // CHECK-EH: [[T0:%.*]] = landingpad { i8*, i32 } 121 // CHECK-EH-NEXT: catch i8* null 122 // CHECK-EH-NEXT: [[T1:%.*]] = extractvalue { i8*, i32 } [[T0]], 0 123 // CHECK-EH-NEXT: call void @__clang_call_terminate(i8* [[T1]]) [[NR_NUW:#[0-9]+]] 124 // CHECK-EH-NEXT: unreachable 125 126 } 127 128 // CHECK-LABEL: define void @_Z5test3b 129 X test3(bool B) { 130 // CHECK: tail call {{.*}} @_ZN1XC1Ev 131 // CHECK-NOT: call {{.*}} @_ZN1XC1ERKS_ 132 // CHECK: call {{.*}} @_ZN1XC1Ev 133 // CHECK: call {{.*}} @_ZN1XC1ERKS_ 134 if (B) { 135 X y; 136 return y; 137 } 138 // FIXME: we should NRVO this variable too. 139 X x; 140 return x; 141 } 142 143 extern "C" void exit(int) throw(); 144 145 // CHECK-LABEL: define void @_Z5test4b 146 X test4(bool B) { 147 { 148 // CHECK: tail call {{.*}} @_ZN1XC1Ev 149 X x; 150 // CHECK: br i1 151 if (B) 152 return x; 153 } 154 // CHECK: tail call {{.*}} @_ZN1XD1Ev 155 // CHECK: tail call void @exit(i32 1) 156 exit(1); 157 } 158 159 #ifdef __EXCEPTIONS 160 // CHECK-EH-LABEL: define void @_Z5test5 161 void may_throw(); 162 X test5() { 163 try { 164 may_throw(); 165 } catch (X x) { 166 // CHECK-EH: invoke {{.*}} @_ZN1XC1ERKS_ 167 // CHECK-EH: call void @__cxa_end_catch() 168 // CHECK-EH: ret void 169 return x; 170 } 171 } 172 #endif 173 174 // rdar://problem/10430868 175 // CHECK-LABEL: define void @_Z5test6v 176 X test6() { 177 X a __attribute__((aligned(8))); 178 return a; 179 // CHECK: [[A:%.*]] = alloca [[X:%.*]], align 8 180 // CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds %class.X, %class.X* [[A]], i32 0, i32 0 181 // CHECK-NEXT: call void @llvm.lifetime.start(i64 1, i8* [[PTR]]) 182 // CHECK-NEXT: call {{.*}} @_ZN1XC1Ev([[X]]* nonnull [[A]]) 183 // CHECK-NEXT: call {{.*}} @_ZN1XC1ERKS_([[X]]* {{%.*}}, [[X]]* nonnull dereferenceable({{[0-9]+}}) [[A]]) 184 // CHECK-NEXT: call {{.*}} @_ZN1XD1Ev([[X]]* nonnull [[A]]) 185 // CHECK-NEXT: call void @llvm.lifetime.end(i64 1, i8* [[PTR]]) 186 // CHECK-NEXT: ret void 187 } 188 189 // CHECK-LABEL: define void @_Z5test7b 190 X test7(bool b) { 191 // CHECK: tail call {{.*}} @_ZN1XC1Ev 192 // CHECK-NEXT: ret 193 if (b) { 194 X x; 195 return x; 196 } 197 return X(); 198 } 199 200 // CHECK-LABEL: define void @_Z5test8b 201 X test8(bool b) { 202 // CHECK: tail call {{.*}} @_ZN1XC1Ev 203 // CHECK-NEXT: ret 204 if (b) { 205 X x; 206 return x; 207 } else { 208 X y; 209 return y; 210 } 211 } 212 213 Y<int> test9() { 214 Y<int>::f(); 215 } 216 217 // CHECK-LABEL: define linkonce_odr void @_ZN1YIiE1fEv 218 // CHECK: tail call {{.*}} @_ZN1YIiEC1Ev 219 220 // CHECK-EH: attributes [[NR_NUW]] = { noreturn nounwind } 221
