1 // RUN: %clang_cc1 -no-enable-noundef-analysis -std=c++11 -triple i386-linux -emit-llvm -o - %s | FileCheck %s --check-prefix=ITANIUM
2 // RUN: %clang_cc1 -no-enable-noundef-analysis -std=c++11 -triple x86_64-darwin -emit-llvm -o - %s | FileCheck %s --check-prefix=ITANIUM
3 // RUN: %clang_cc1 -no-enable-noundef-analysis -std=c++11 -triple arm64-ehabi -emit-llvm -o - %s | FileCheck %s --check-prefix=ITANIUM
4 // RUN: %clang_cc1 -no-enable-noundef-analysis -std=c++11 -triple i386-windows -emit-llvm -o - %s | FileCheck %s --check-prefix=MSABI --check-prefix=WIN32
5 // RUN: %clang_cc1 -no-enable-noundef-analysis -std=c++11 -triple x86_64-windows -emit-llvm -o - %s | FileCheck %s --check-prefix=MSABI --check-prefix=WIN64
6
7 // PR63618: make sure we generate definitions for all the globals defined in the test
8 // MSABI: @"?b@@3UB@@A" = {{.*}} zeroinitializer
9 // MSABI: @"?d@@3UD@@A" = {{.*}} zeroinitializer
10 // MSABI: @"?b@noninline_nonvirt@@3UB@1@A" = {{.*}} zeroinitializer
11 // MSABI: @"?c@noninline_nonvirt@@3UC@1@A" = {{.*}} zeroinitializer
12 // MSABI: @"?b@noninline_virt@@3UB@1@A" = {{.*}} zeroinitializer
13 // MSABI: @"?c@noninline_virt@@3UC@1@A" = {{.*}} zeroinitializer
14 // MSABI: @"?b@inalloca_nonvirt@@3UB@1@A" = {{.*}} zeroinitializer
15 // MSABI: @"?c@inalloca_nonvirt@@3UC@1@A" = {{.*}} zeroinitializer
16 // MSABI: @"?b@inalloca_virt@@3UB@1@A" = {{.*}} zeroinitializer
17 // MSABI: @"?c@inalloca_virt@@3UC@1@A" = {{.*}} zeroinitializer
18 // MSABI: @"?b@inline_nonvirt@@3UB@1@A" = {{.*}} zeroinitializer
19 // MSABI: @"?c@inline_nonvirt@@3UC@1@A" = {{.*}} zeroinitializer
20 // MSABI: @"?b@inline_virt@@3UB@1@A" = {{.*}} zeroinitializer
21 // MSABI: @"?c@inline_virt@@3UC@1@A" = {{.*}} zeroinitializer
22
23 // MSABI-NOT: @this
24
25 // PR12219
26 struct A { A(int); virtual ~A(); };
27 struct B : A { using A::A; ~B(); };
~B()28 B::~B() {}
29
30 B b(123);
31
32 struct C { template<typename T> C(T); };
33 struct D : C { using C::C; };
34 D d(123);
35
36 // ITANIUM-LABEL: define{{.*}} void @_ZN1BD2Ev
37 // ITANIUM-LABEL: define{{.*}} void @_ZN1BD1Ev
38 // ITANIUM-LABEL: define{{.*}} void @_ZN1BD0Ev
39 // WIN32-LABEL: define {{.*}}void @"??1B@@UAE@XZ"
40 // WIN64-LABEL: define {{.*}}void @"??1B@@UEAA@XZ"
41
42 // ITANIUM-LABEL: define linkonce_odr void @_ZN1BCI11AEi(
43 // ITANIUM: call void @_ZN1BCI21AEi(
44
45 // ITANIUM-LABEL: define linkonce_odr void @_ZN1DCI11CIiEET_(
46 // ITANIUM: call void @_ZN1DCI21CIiEET_(
47
48 // WIN32-LABEL: define internal {{.*}} @"??0B@@QAE@H@Z"(
49 // WIN32: call {{.*}} @"??0A@@QAE@H@Z"(
50 // WIN64-LABEL: define internal {{.*}} @"??0B@@QEAA@H@Z"(
51 // WIN64: call {{.*}} @"??0A@@QEAA@H@Z"(
52
53 // WIN32-LABEL: define internal {{.*}} @"??0D@@QAE@H@Z"(
54 // WIN32: call {{.*}} @"??$?0H@C@@QAE@H@Z"
55 // WIN64-LABEL: define internal {{.*}} @"??0D@@QEAA@H@Z"(
56 // WIN64: call {{.*}} @"??$?0H@C@@QEAA@H@Z"
57
58 struct Q { Q(int); Q(const Q&); ~Q(); };
59 struct Z { Z(); Z(int); ~Z(); int n; };
60
61 namespace noninline_nonvirt {
62 struct A { A(int, Q&&, void *__attribute__((pass_object_size(0)))); int n; };
63 struct B : Z, A { Z z; using A::A; };
64 B b(1, 2, &b);
65 // ITANIUM-LABEL: define {{.*}} @__cxx_global_var_init
66 // ITANIUM: call void @_ZN1QC1Ei({{.*}} %[[TMP:.*]], i32 2)
67 // ITANIUM: call void @_ZN17noninline_nonvirt1BCI1NS_1AEEiO1QPvU17pass_object_size0({{.*}} @_ZN17noninline_nonvirt1bE, i32 1, {{.*}} %[[TMP]], ptr @_ZN17noninline_nonvirt1bE{{.*}}, i{{32|64}} 12)
68 // ITANIUM: call void @_ZN1QD1Ev({{.*}} %[[TMP]])
69 // ITANIUM: call i32 @__cxa_atexit(
70
71 // Complete object ctor for B delegates to base object ctor.
72 // ITANIUM-LABEL: define linkonce_odr void @_ZN17noninline_nonvirt1BCI1NS_1AEEiO1QPvU17pass_object_size0(
73 // ITANIUM: call void @_ZN17noninline_nonvirt1BCI2NS_1AEEiO1QPvU17pass_object_size0({{.*}}, i32 {{.*}}, ptr {{.*}}, ptr {{.*}}, i{{32|64}} {{.*}})
74
75 // In MSABI, we don't have ctor variants. B ctor forwards to A ctor.
76 // MSABI-LABEL: define internal {{.*}} @"??0B@noninline_nonvirt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}})
77 // MSABI: call {{.*}} @"??0Z@@Q{{AE|EAA}}@XZ"(
78 // MSABI: call {{.*}} @"??0A@noninline_nonvirt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}})
79 // MSABI: call {{.*}} @"??0Z@@Q{{AE|EAA}}@XZ"(
80
81 struct C : B { using B::B; };
82 C c(1, 2, &c);
83 // Complete object ctor for C delegates.
84 // ITANIUM-LABEL: define linkonce_odr void @_ZN17noninline_nonvirt1CCI1NS_1AEEiO1QPvU17pass_object_size0(
85 // ITANIUM: call void @_ZN17noninline_nonvirt1CCI2NS_1AEEiO1QPvU17pass_object_size0({{.*}}, i32 {{.*}}, ptr {{.*}}, ptr {{.*}}, i{{32|64}} {{.*}})
86
87 // MSABI-LABEL: define internal {{.*}} @"??0C@noninline_nonvirt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}})
88 // MSABI: call {{.*}} @"??0B@noninline_nonvirt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}})
89 }
90
91 namespace noninline_virt {
92 struct A { A(int, Q&&, void *__attribute__((pass_object_size(0)))); int n; };
93 struct B : Z, virtual A { Z z; using A::A; };
94 B b(1, 2, &b);
95 // Complete object ctor forwards to A ctor then constructs Zs.
96 // ITANIUM-LABEL: define linkonce_odr void @_ZN14noninline_virt1BCI1NS_1AEEiO1QPvU17pass_object_size0(
97 // ITANIUM: call void @_ZN14noninline_virt1AC2EiO1QPvU17pass_object_size0({{.*}} %{{.*}}, i32 %{{.*}}, ptr {{.*}}, ptr {{.*}}, i{{32|64}} %{{.*}}
98 // ITANIUM: call void @_ZN1ZC2Ev(
99 // ITANIUM: store {{.*}} @_ZTVN14noninline_virt1BE
100 // ITANIUM: call void @_ZN1ZC1Ev(
101
102 // MSABI-LABEL: define internal {{.*}} @"??0B@noninline_virt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}}, i32 %{{.*}})
103 // MSABI: %[[COMPLETE:.*]] = icmp ne
104 // MSABI: br i1 %[[COMPLETE]],
105 // MSABI: call {{.*}} @"??0A@noninline_virt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}})
106 // MSABI: br
107 // MSABI: call {{.*}} @"??0Z@@Q{{AE|EAA}}@XZ"(
108 // MSABI: call {{.*}} @"??0Z@@Q{{AE|EAA}}@XZ"(
109
110 struct C : B { using B::B; };
111 C c(1, 2, &c);
112 // Complete object ctor forwards to A ctor, then calls B's base inheriting
113 // constructor, which takes no arguments other than the this pointer and VTT.
114 // ITANIUM-LABEL: define linkonce_odr void @_ZN14noninline_virt1CCI1NS_1AEEiO1QPvU17pass_object_size0(
115 // ITANIUM: call void @_ZN14noninline_virt1AC2EiO1QPvU17pass_object_size0({{.*}} %{{.*}}, i32 %{{.*}}, ptr {{.*}}, ptr %{{.*}}, i{{32|64}} %{{.*}})
116 // ITANIUM: call void @_ZN14noninline_virt1BCI2NS_1AEEiO1QPvU17pass_object_size0(ptr {{[^,]*}} %{{.*}}, ptr getelementptr inbounds ([2 x ptr], ptr @_ZTTN14noninline_virt1CE, i64 0, i64 1))
117 // ITANIUM: store {{.*}} @_ZTVN14noninline_virt1CE
118
119 // C constructor forwards to B constructor and A constructor. We pass the args
120 // to both. FIXME: Can we pass undef here instead, for the base object
121 // constructor call?
122 // MSABI-LABEL: define internal {{.*}} @"??0C@noninline_virt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}}, i32 %{{.*}})
123 // MSABI: %[[COMPLETE:.*]] = icmp ne
124 // MSABI: br i1 %[[COMPLETE]],
125 // MSABI: call {{.*}} @"??0A@noninline_virt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}})
126 // MSABI: br
127 // MSABI: call {{.*}} @"??0B@noninline_virt@@Q{{AE|EAA}}@H$$Q{{E?}}AUQ@@P{{E?}}AXW4__pass_object_size0@__clang@@@Z"(ptr{{.*}}, i32{{.*}}, ptr{{.*}}, ptr{{.*}}, i{{32|64}}{{.*}}, i32 0)
128 }
129
130 // For MSABI only, check that inalloca arguments result in inlining.
131 namespace inalloca_nonvirt {
132 struct A { A(Q, int, Q, Q&&); int n; };
133 struct B : Z, A { Z z; using A::A; };
134 B b(1, 2, 3, 4);
135 // No inlining implied for Itanium.
136 // ITANIUM-LABEL: define linkonce_odr void @_ZN16inalloca_nonvirt1BCI1NS_1AEE1QiS1_OS1_(
137 // ITANIUM: call void @_ZN16inalloca_nonvirt1BCI2NS_1AEE1QiS1_OS1_(
138
139 // MSABI-LABEL: define internal void @"??__Eb@inalloca_nonvirt@@YAXXZ"(
140
141 // On Win32, the inalloca call can't be forwarded so we force inlining.
142 // WIN32: %[[TMP:.*]] = alloca
143 // WIN32: call ptr @llvm.stacksave.p0()
144 // WIN32: %[[ARGMEM:.*]] = alloca inalloca
145 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
146 // WIN32: %[[ARG3:.*]] = getelementptr {{.*}} %[[ARGMEM]]
147 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
148 // WIN32: %[[ARG1:.*]] = getelementptr {{.*}} %[[ARGMEM]]
149 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
150 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
151 // WIN32: %[[ARG2:.*]] = getelementptr {{.*}} %[[ARGMEM]]
152 // WIN32: store i32 2, ptr %[[ARG2]]
153 // WIN32: %[[ARG4:.*]] = getelementptr {{.*}} %[[ARGMEM]]
154 // WIN32: store ptr %[[TMP]], ptr %[[ARG4]]
155 // WIN32: call {{.*}} @"??0A@inalloca_nonvirt@@QAE@UQ@@H0$$QAU2@@Z"(ptr{{[^,]*}}, ptr inalloca(<{{.*}}>) %[[ARGMEM]])
156 // WIN32: call void @llvm.stackrestore.p0(
157 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
158 // WIN32: call {{.*}} @"??1Q@@QAE@XZ"(
159
160 // On Win64, the Q arguments would be destroyed in the callee. We don't yet
161 // support that in the non-inlined case, so we force inlining.
162 // WIN64: %[[TMP:.*]] = alloca
163 // WIN64: %[[ARG3:.*]] = alloca
164 // WIN64: %[[ARG1:.*]] = alloca
165 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
166 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
167 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
168 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
169 // WIN64: call {{.*}} @"??0A@inalloca_nonvirt@@QEAA@UQ@@H0$$QEAU2@@Z"(ptr{{.*}}, ptr %[[ARG1]], i32 2, ptr %[[ARG3]], ptr{{.*}} %[[TMP]])
170 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
171 // WIN64: call void @"??1Q@@QEAA@XZ"(ptr {{[^,]*}} %[[TMP]])
172
173 struct C : B { using B::B; };
174 C c(1, 2, 3, 4);
175 // MSABI-LABEL: define internal void @"??__Ec@inalloca_nonvirt@@YAXXZ"(
176
177 // On Win32, the inalloca call can't be forwarded so we force inlining.
178 // WIN32: %[[TMP:.*]] = alloca
179 // WIN32: call ptr @llvm.stacksave.p0()
180 // WIN32: %[[ARGMEM:.*]] = alloca inalloca
181 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
182 // WIN32: %[[ARG3:.*]] = getelementptr {{.*}} %[[ARGMEM]]
183 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
184 // WIN32: %[[ARG1:.*]] = getelementptr {{.*}} %[[ARGMEM]]
185 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
186 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
187 // WIN32: %[[ARG2:.*]] = getelementptr {{.*}} %[[ARGMEM]]
188 // WIN32: store i32 2, ptr %[[ARG2]]
189 // WIN32: %[[ARG4:.*]] = getelementptr {{.*}} %[[ARGMEM]]
190 // WIN32: store ptr %[[TMP]], ptr %[[ARG4]]
191 // WIN32: call {{.*}} @"??0A@inalloca_nonvirt@@QAE@UQ@@H0$$QAU2@@Z"(ptr{{[^,]*}}, ptr inalloca(<{{.*}}>) %[[ARGMEM]])
192 // WIN32: call void @llvm.stackrestore.p0(
193 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
194 // WIN32: call {{.*}} @"??1Q@@QAE@XZ"(
195
196 // On Win64, the Q arguments would be destroyed in the callee. We don't yet
197 // support that in the non-inlined case, so we force inlining.
198 // WIN64: %[[TMP:.*]] = alloca
199 // WIN64: %[[ARG3:.*]] = alloca
200 // WIN64: %[[ARG1:.*]] = alloca
201 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
202 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
203 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
204 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
205 // WIN64: call {{.*}} @"??0A@inalloca_nonvirt@@QEAA@UQ@@H0$$QEAU2@@Z"(ptr{{.*}}, ptr %[[ARG1]], i32 2, ptr %[[ARG3]], ptr{{.*}} %[[TMP]])
206 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
207 // WIN64: call void @"??1Q@@QEAA@XZ"(ptr {{[^,]*}} %[[TMP]])
208 }
209
210 namespace inalloca_virt {
211 struct A { A(Q, int, Q, Q&&); int n; };
212 struct B : Z, virtual A { Z z; using A::A; };
213 B b(1, 2, 3, 4);
214
215 // MSABI-LABEL: define internal void @"??__Eb@inalloca_virt@@YAXXZ"(
216
217 // On Win32, the inalloca call can't be forwarded so we force inlining.
218 // WIN32: %[[TMP:.*]] = alloca
219 // WIN32: call ptr @llvm.stacksave.p0()
220 // WIN32: %[[ARGMEM:.*]] = alloca inalloca
221 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
222 // WIN32: %[[ARG3:.*]] = getelementptr {{.*}} %[[ARGMEM]]
223 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
224 // WIN32: %[[ARG1:.*]] = getelementptr {{.*}} %[[ARGMEM]]
225 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
226 // FIXME: It's dumb to round-trip this though memory and generate a branch.
227 // WIN32: store i32 1, ptr %[[IS_MOST_DERIVED_ADDR:.*]]
228 // WIN32: %[[IS_MOST_DERIVED:.*]] = load i32, ptr %[[IS_MOST_DERIVED_ADDR]]
229 // WIN32: %[[IS_MOST_DERIVED_i1:.*]] = icmp ne i32 %[[IS_MOST_DERIVED]], 0
230 // WIN32: br i1 %[[IS_MOST_DERIVED_i1]]
231 //
232 // WIN32: store {{.*}} @"??_8B@inalloca_virt@@7B@"
233 // WIN32: %[[ARG2:.*]] = getelementptr {{.*}} %[[ARGMEM]]
234 // WIN32: store i32 2, ptr %[[ARG2]]
235 // WIN32: %[[ARG4:.*]] = getelementptr {{.*}} %[[ARGMEM]]
236 // WIN32: store ptr %[[TMP]], ptr %[[ARG4]]
237 // WIN32: call {{.*}} @"??0A@inalloca_virt@@QAE@UQ@@H0$$QAU2@@Z"(ptr{{[^,]*}}, ptr inalloca(<{{.*}}>) %[[ARGMEM]])
238 // WIN32: call void @llvm.stackrestore.p0(
239 // WIN32: br
240 //
241 // Note that if we jumped directly to here we would fail to stackrestore and
242 // destroy the parameters, but that's not actually possible.
243 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
244 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
245 // WIN32: call {{.*}} @"??1Q@@QAE@XZ"(
246
247 // On Win64, the Q arguments would be destroyed in the callee. We don't yet
248 // support that in the non-inlined case, so we force inlining.
249 // WIN64: %[[TMP:.*]] = alloca
250 // WIN64: %[[ARG3:.*]] = alloca
251 // WIN64: %[[ARG1:.*]] = alloca
252 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
253 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
254 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
255 // WIN64: br i1
256 // WIN64: call {{.*}} @"??0A@inalloca_virt@@QEAA@UQ@@H0$$QEAU2@@Z"(ptr{{.*}}, ptr %[[ARG1]], i32 2, ptr %[[ARG3]], ptr{{.*}} %[[TMP]])
257 // WIN64: br
258 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
259 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
260 // WIN64: call void @"??1Q@@QEAA@XZ"(ptr {{[^,]*}} %[[TMP]])
261
262 struct C : B { using B::B; };
263 C c(1, 2, 3, 4);
264 // ITANIUM-LABEL: define linkonce_odr void @_ZN13inalloca_virt1CD1Ev(
265
266 // MSABI-LABEL: define internal void @"??__Ec@inalloca_virt@@YAXXZ"(
267
268 // On Win32, the inalloca call can't be forwarded so we force inlining.
269 // WIN32: %[[TMP:.*]] = alloca
270 // WIN32: call ptr @llvm.stacksave.p0()
271 // WIN32: %[[ARGMEM:.*]] = alloca inalloca
272 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
273 // WIN32: %[[ARG3:.*]] = getelementptr {{.*}} %[[ARGMEM]]
274 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
275 // WIN32: %[[ARG1:.*]] = getelementptr {{.*}} %[[ARGMEM]]
276 // WIN32: call {{.*}} @"??0Q@@QAE@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
277 // WIN32: store i32 1, ptr %[[IS_MOST_DERIVED_ADDR:.*]]
278 // WIN32: %[[IS_MOST_DERIVED:.*]] = load i32, ptr %[[IS_MOST_DERIVED_ADDR]]
279 // WIN32: %[[IS_MOST_DERIVED_i1:.*]] = icmp ne i32 %[[IS_MOST_DERIVED]], 0
280 // WIN32: br i1 %[[IS_MOST_DERIVED_i1]]
281 //
282 // WIN32: store {{.*}} @"??_8C@inalloca_virt@@7B@"
283 // WIN32: %[[ARG2:.*]] = getelementptr {{.*}} %[[ARGMEM]]
284 // WIN32: store i32 2, ptr %[[ARG2]]
285 // WIN32: %[[ARG4:.*]] = getelementptr {{.*}} %[[ARGMEM]]
286 // WIN32: store ptr %[[TMP]], ptr %[[ARG4]]
287 // WIN32: call {{.*}} @"??0A@inalloca_virt@@QAE@UQ@@H0$$QAU2@@Z"(ptr{{[^,]*}}, ptr inalloca(<{{.*}}>) %[[ARGMEM]])
288 // WIN32: call void @llvm.stackrestore.p0(
289 // WIN32: br
290 //
291 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
292 // WIN32: call {{.*}} @"??0Z@@QAE@XZ"(
293 // WIN32: call {{.*}} @"??1Q@@QAE@XZ"(
294
295 // On Win64, the Q arguments would be destroyed in the callee. We don't yet
296 // support that in the non-inlined case, so we force inlining.
297 // WIN64: %[[TMP:.*]] = alloca
298 // WIN64: %[[ARG3:.*]] = alloca
299 // WIN64: %[[ARG1:.*]] = alloca
300 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[TMP]], i32 4)
301 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG3]], i32 3)
302 // WIN64: call {{.*}} @"??0Q@@QEAA@H@Z"(ptr {{[^,]*}} %[[ARG1]], i32 1)
303 // WIN64: br i1
304 // WIN64: store {{.*}} @"??_8C@inalloca_virt@@7B@"
305 // WIN64: call {{.*}} @"??0A@inalloca_virt@@QEAA@UQ@@H0$$QEAU2@@Z"(ptr{{.*}}, ptr %[[ARG1]], i32 2, ptr %[[ARG3]], ptr{{.*}} %[[TMP]])
306 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
307 // WIN64: call {{.*}} @"??0Z@@QEAA@XZ"(
308 // WIN64: call void @"??1Q@@QEAA@XZ"(ptr {{[^,]*}} %[[TMP]])
309 }
310
311 namespace inline_nonvirt {
312 struct A { A(Q, int, Q, Q&&, ...); int n; };
313 struct B : Z, A { Z z; using A::A; };
314 B b(1, 2, 3, 4, 5, 6);
315 // Inlined all the way down to the A ctor.
316 // ITANIUM-LABEL: define {{.*}} @__cxx_global_var_init
317 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 1)
318 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 3)
319 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 4)
320 // ITANIUM: call void @_ZN1ZC2Ev(
321 // ITANIUM: %[[A:.*]] = getelementptr {{.*}}, i{{32|64}} 4
322 // ITANIUM: call void ({{.*}}, ...) @_ZN14inline_nonvirt1AC2E1QiS1_OS1_z(ptr {{[^,]*}} %[[A]], {{.*}}, i32 2, {{.*}}, {{.*}}, i32 5, i32 6)
323 // ITANIUM: %[[Z_MEMBER:.*]] = getelementptr {{.*}}, i32 0, i32 2
324 // ITANIUM: call void @_ZN1ZC1Ev({{.*}} %[[Z_MEMBER]])
325 // ITANIUM: call void @_ZN1QD1Ev(
326 // ITANIUM: call void @_ZN1QD1Ev(
327 // ITANIUM: call void @_ZN1QD1Ev(
328
329 struct C : B { using B::B; };
330 C c(1, 2, 3, 4, 5, 6);
331 // Inlined all the way down to the A ctor.
332 // ITANIUM-LABEL: define {{.*}} @__cxx_global_var_init
333 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 1)
334 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 3)
335 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 4)
336 // ITANIUM: call void @_ZN1ZC2Ev(
337 // ITANIUM: %[[A:.*]] = getelementptr {{.*}}, i{{32|64}} 4
338 // ITANIUM: call void ({{.*}}, ...) @_ZN14inline_nonvirt1AC2E1QiS1_OS1_z(ptr {{[^,]*}} %[[A]], {{.*}}, i32 2, {{.*}}, {{.*}}, i32 5, i32 6)
339 // ITANIUM: %[[Z_MEMBER:.*]] = getelementptr {{.*}} %{{.*}}, i32 0, i32 2
340 // ITANIUM: call void @_ZN1ZC1Ev({{.*}} %[[Z_MEMBER]])
341 // ITANIUM: call void @_ZN1QD1Ev(
342 // ITANIUM: call void @_ZN1QD1Ev(
343 // ITANIUM: call void @_ZN1QD1Ev(
344 }
345
346 namespace inline_virt {
347 struct A { A(Q, int, Q, Q&&, ...); int n; };
348 struct B : Z, virtual A { Z z; using A::A; };
349 B b(1, 2, 3, 4, 5, 6);
350 // Inlined all the way down to the A ctor.
351 // ITANIUM-LABEL: define {{.*}} @__cxx_global_var_init
352 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 1)
353 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 3)
354 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 4)
355 // ITANIUM: %[[A:.*]] = getelementptr {{.*}}, i{{32|64}} {{12|16}}
356 // ITANIUM: call void ({{.*}}, ...) @_ZN11inline_virt1AC2E1QiS1_OS1_z(ptr {{[^,]*}} %[[A]], {{.*}}, i32 2, {{.*}}, {{.*}}, i32 5, i32 6)
357 // ITANIUM: call void @_ZN1ZC2Ev(
358 // ITANIUM: call void @_ZN1ZC1Ev(
359 // ITANIUM: call void @_ZN1QD1Ev(
360 // ITANIUM: call void @_ZN1QD1Ev(
361 // ITANIUM: call void @_ZN1QD1Ev(
362
363 struct C : B { using B::B; };
364 C c(1, 2, 3, 4, 5, 6);
365 // Inlined all the way down to the A ctor, except that we can just call the
366 // B base inheriting constructor to construct that portion (it doesn't need
367 // the forwarded arguments).
368 // ITANIUM-LABEL: define {{.*}} @__cxx_global_var_init
369 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 1)
370 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 3)
371 // ITANIUM: call void @_ZN1QC1Ei({{.*}}, i32 4)
372 // ITANIUM: %[[A:.*]] = getelementptr {{.*}}, i{{32|64}} {{12|16}}
373 // ITANIUM: call void ({{.*}}, ...) @_ZN11inline_virt1AC2E1QiS1_OS1_z(ptr {{[^,]*}} %[[A]], {{.*}}, i32 2, {{.*}}, {{.*}}, i32 5, i32 6)
374 // ITANIUM: call void @_ZN11inline_virt1BCI2NS_1AEE1QiS1_OS1_z({{[^,]*}}, ptr getelementptr inbounds ([2 x ptr], ptr @_ZTTN11inline_virt1CE, i64 0, i64 1))
375 // ITANIUM: store {{.*}} @_ZTVN11inline_virt1CE
376 // ITANIUM: call void @_ZN1QD1Ev(
377 // ITANIUM: call void @_ZN1QD1Ev(
378 // ITANIUM: call void @_ZN1QD1Ev(
379
380 // B base object inheriting constructor does not get passed arguments.
381 // ITANIUM-LABEL: define linkonce_odr void @_ZN11inline_virt1BCI2NS_1AEE1QiS1_OS1_z(
382 // ITANIUM-NOT: call
383 // ITANIUM: call void @_ZN1ZC2Ev(
384 // ITANIUM-NOT: call
385 // VTT -> vtable
386 // ITANIUM: store
387 // ITANIUM-NOT: call
388 // ITANIUM: call void @_ZN1ZC1Ev(
389 // ITANIUM-NOT: call
390 // ITANIUM: }
391 }
392
393 // ITANIUM-LABEL: define linkonce_odr void @_ZN1BCI21AEi(
394 // ITANIUM: call void @_ZN1AC2Ei(
395
396 // ITANIUM-LABEL: define linkonce_odr void @_ZN1DCI21CIiEET_(
397 // ITANIUM: call void @_ZN1CC2IiEET_(
398
399 // ITANIUM-LABEL: define linkonce_odr void @_ZN17noninline_nonvirt1BCI2NS_1AEEiO1QPvU17pass_object_size0(
400 // ITANIUM: call void @_ZN1ZC2Ev(
401 // ITANIUM: call void @_ZN17noninline_nonvirt1AC2EiO1QPvU17pass_object_size0(
402
403 // ITANIUM-LABEL: define linkonce_odr void @_ZN17noninline_nonvirt1CCI2NS_1AEEiO1QPvU17pass_object_size0(
404 // ITANIUM: call void @_ZN17noninline_nonvirt1BCI2NS_1AEEiO1QPvU17pass_object_size0(
405