Mercurial > hg > CbC > CbC_llvm

annotate clang/test/CodeGenCXX/pod-member-memcpys.cpp @ 206:f17a3b42b08b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added tag before-12 for changeset b7591485f4cd
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 07 Jun 2021 21:25:57 +0900
parents 0572611fdcc8
children 2e18cbf3894f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
150
anatofuz
parents:
diff changeset
1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -std=c++03 -fexceptions -fcxx-exceptions -o - %s | FileCheck %s
anatofuz
parents:
diff changeset
2 // RUN: %clang_cc1 -triple i386-apple-darwin10 -emit-llvm -std=c++03 -o - %s | FileCheck --check-prefix=CHECK-2 %s
anatofuz
parents:
diff changeset
3
anatofuz
parents:
diff changeset
4 struct POD {
anatofuz
parents:
diff changeset
5 int w, x, y, z;
anatofuz
parents:
diff changeset
6 };
anatofuz
parents:
diff changeset
7
anatofuz
parents:
diff changeset
8 struct PODLike {
anatofuz
parents:
diff changeset
9 int w, x, y, z;
anatofuz
parents:
diff changeset
10 PODLike();
anatofuz
parents:
diff changeset
11 ~PODLike();
anatofuz
parents:
diff changeset
12 };
anatofuz
parents:
diff changeset
13
anatofuz
parents:
diff changeset
14 struct NonPOD {
anatofuz
parents:
diff changeset
15 NonPOD();
anatofuz
parents:
diff changeset
16 NonPOD(const NonPOD&);
anatofuz
parents:
diff changeset
17 NonPOD& operator=(const NonPOD&);
anatofuz
parents:
diff changeset
18 };
anatofuz
parents:
diff changeset
19
anatofuz
parents:
diff changeset
20 struct Basic {
anatofuz
parents:
diff changeset
21 int a, b, c, d;
anatofuz
parents:
diff changeset
22 NonPOD np;
anatofuz
parents:
diff changeset
23 int w, x, y, z;
anatofuz
parents:
diff changeset
24 };
anatofuz
parents:
diff changeset
25
anatofuz
parents:
diff changeset
26 struct PODMember {
anatofuz
parents:
diff changeset
27 int a, b, c, d;
anatofuz
parents:
diff changeset
28 POD p;
anatofuz
parents:
diff changeset
29 NonPOD np;
anatofuz
parents:
diff changeset
30 int w, x, y, z;
anatofuz
parents:
diff changeset
31 };
anatofuz
parents:
diff changeset
32
anatofuz
parents:
diff changeset
33 struct PODLikeMember {
anatofuz
parents:
diff changeset
34 int a, b, c, d;
anatofuz
parents:
diff changeset
35 PODLike pl;
anatofuz
parents:
diff changeset
36 NonPOD np;
anatofuz
parents:
diff changeset
37 int w, x, y, z;
anatofuz
parents:
diff changeset
38 };
anatofuz
parents:
diff changeset
39
anatofuz
parents:
diff changeset
40 struct ArrayMember {
anatofuz
parents:
diff changeset
41 int a, b, c, d;
anatofuz
parents:
diff changeset
42 int e[12];
anatofuz
parents:
diff changeset
43 NonPOD np;
anatofuz
parents:
diff changeset
44 int f[12];
anatofuz
parents:
diff changeset
45 int w, x, y, z;
anatofuz
parents:
diff changeset
46 };
anatofuz
parents:
diff changeset
47
anatofuz
parents:
diff changeset
48 struct ZeroLengthArrayMember {
anatofuz
parents:
diff changeset
49 NonPOD np;
anatofuz
parents:
diff changeset
50 int a;
anatofuz
parents:
diff changeset
51 int b[0];
anatofuz
parents:
diff changeset
52 int c;
anatofuz
parents:
diff changeset
53 };
anatofuz
parents:
diff changeset
54
anatofuz
parents:
diff changeset
55 struct VolatileMember {
anatofuz
parents:
diff changeset
56 int a, b, c, d;
anatofuz
parents:
diff changeset
57 volatile int v;
anatofuz
parents:
diff changeset
58 NonPOD np;
anatofuz
parents:
diff changeset
59 int w, x, y, z;
anatofuz
parents:
diff changeset
60 };
anatofuz
parents:
diff changeset
61
anatofuz
parents:
diff changeset
62 struct BitfieldMember {
anatofuz
parents:
diff changeset
63 int a, b, c, d;
anatofuz
parents:
diff changeset
64 NonPOD np;
anatofuz
parents:
diff changeset
65 int w : 6;
anatofuz
parents:
diff changeset
66 int x : 6;
anatofuz
parents:
diff changeset
67 int y : 6;
anatofuz
parents:
diff changeset
68 int z : 6;
anatofuz
parents:
diff changeset
69 };
anatofuz
parents:
diff changeset
70
anatofuz
parents:
diff changeset
71 struct BitfieldMember2 {
anatofuz
parents:
diff changeset
72 unsigned a : 1;
anatofuz
parents:
diff changeset
73 unsigned b, c, d;
anatofuz
parents:
diff changeset
74 NonPOD np;
anatofuz
parents:
diff changeset
75 };
anatofuz
parents:
diff changeset
76
anatofuz
parents:
diff changeset
77 struct BitfieldMember3 {
anatofuz
parents:
diff changeset
78 virtual void f();
anatofuz
parents:
diff changeset
79 int : 8;
anatofuz
parents:
diff changeset
80 int x : 1;
anatofuz
parents:
diff changeset
81 int y;
anatofuz
parents:
diff changeset
82 };
anatofuz
parents:
diff changeset
83
anatofuz
parents:
diff changeset
84 struct InnerClassMember {
anatofuz
parents:
diff changeset
85 struct {
anatofuz
parents:
diff changeset
86 int a, b, c, d;
anatofuz
parents:
diff changeset
87 } a;
anatofuz
parents:
diff changeset
88 int b, c, d, e;
anatofuz
parents:
diff changeset
89 NonPOD np;
anatofuz
parents:
diff changeset
90 int w, x, y, z;
anatofuz
parents:
diff changeset
91 };
anatofuz
parents:
diff changeset
92
anatofuz
parents:
diff changeset
93 struct ReferenceMember {
anatofuz
parents:
diff changeset
94 ReferenceMember(int &a, int &b, int &c, int &d)
anatofuz
parents:
diff changeset
95 : a(a), b(b), c(c), d(d) {}
anatofuz
parents:
diff changeset
96 int &a;
anatofuz
parents:
diff changeset
97 int &b;
anatofuz
parents:
diff changeset
98 NonPOD np;
anatofuz
parents:
diff changeset
99 int &c;
anatofuz
parents:
diff changeset
100 int &d;
anatofuz
parents:
diff changeset
101 };
anatofuz
parents:
diff changeset
102
anatofuz
parents:
diff changeset
103 struct __attribute__((packed)) PackedMembers {
anatofuz
parents:
diff changeset
104 char c;
anatofuz
parents:
diff changeset
105 NonPOD np;
anatofuz
parents:
diff changeset
106 int w, x, y, z;
anatofuz
parents:
diff changeset
107 };
anatofuz
parents:
diff changeset
108
anatofuz
parents:
diff changeset
109 // COPY-ASSIGNMENT OPERATORS:
anatofuz
parents:
diff changeset
110
anatofuz
parents:
diff changeset
111 // Assignment operators are output in the order they're encountered.
anatofuz
parents:
diff changeset
112
anatofuz
parents:
diff changeset
113 #define CALL_AO(T) void callAO##T(T& a, const T& b) { a = b; }
anatofuz
parents:
diff changeset
114
anatofuz
parents:
diff changeset
115 CALL_AO(Basic)
anatofuz
parents:
diff changeset
116 CALL_AO(PODMember)
anatofuz
parents:
diff changeset
117 CALL_AO(PODLikeMember)
anatofuz
parents:
diff changeset
118 CALL_AO(ArrayMember)
anatofuz
parents:
diff changeset
119 CALL_AO(ZeroLengthArrayMember)
anatofuz
parents:
diff changeset
120 CALL_AO(VolatileMember)
anatofuz
parents:
diff changeset
121 CALL_AO(BitfieldMember)
anatofuz
parents:
diff changeset
122 CALL_AO(InnerClassMember)
anatofuz
parents:
diff changeset
123 CALL_AO(PackedMembers)
anatofuz
parents:
diff changeset
124
anatofuz
parents:
diff changeset
125 // Basic copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
126 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.Basic* @_ZN5BasicaSERKS_(%struct.Basic* %this, %struct.Basic* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
127 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
128 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
129 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
130 // CHECK: ret %struct.Basic*
anatofuz
parents:
diff changeset
131
anatofuz
parents:
diff changeset
132 // PODMember copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
133 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.PODMember* @_ZN9PODMemberaSERKS_(%struct.PODMember* %this, %struct.PODMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
134 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 32, i1 {{.*}})
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
135 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
136 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
137 // CHECK: ret %struct.PODMember*
anatofuz
parents:
diff changeset
138
anatofuz
parents:
diff changeset
139 // PODLikeMember copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
140 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.PODLikeMember* @_ZN13PODLikeMemberaSERKS_(%struct.PODLikeMember* %this, %struct.PODLikeMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
141 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 32, i1 {{.*}})
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
142 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
143 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
144 // CHECK: ret %struct.PODLikeMember*
anatofuz
parents:
diff changeset
145
anatofuz
parents:
diff changeset
146 // ArrayMember copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
147 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.ArrayMember* @_ZN11ArrayMemberaSERKS_(%struct.ArrayMember* %this, %struct.ArrayMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
148 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 64, i1 {{.*}})
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
149 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
150 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 64, i1 {{.*}})
anatofuz
parents:
diff changeset
151 // CHECK: ret %struct.ArrayMember*
anatofuz
parents:
diff changeset
152
anatofuz
parents:
diff changeset
153 // ZeroLengthArrayMember copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
154 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.ZeroLengthArrayMember* @_ZN21ZeroLengthArrayMemberaSERKS_(%struct.ZeroLengthArrayMember* %this, %struct.ZeroLengthArrayMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
155 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
156 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 8, i1 {{.*}})
anatofuz
parents:
diff changeset
157 // CHECK: ret %struct.ZeroLengthArrayMember*
anatofuz
parents:
diff changeset
158
anatofuz
parents:
diff changeset
159 // VolatileMember copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
160 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.VolatileMember* @_ZN14VolatileMemberaSERKS_(%struct.VolatileMember* %this, %struct.VolatileMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
161 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
162 // CHECK: load volatile i32, i32* {{.*}}, align 4
anatofuz
parents:
diff changeset
163 // CHECK: store volatile i32 {{.*}}, align 4
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
164 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
165 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
166 // CHECK: ret %struct.VolatileMember*
anatofuz
parents:
diff changeset
167
anatofuz
parents:
diff changeset
168 // BitfieldMember copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
169 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.BitfieldMember* @_ZN14BitfieldMemberaSERKS_(%struct.BitfieldMember* %this, %struct.BitfieldMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
170 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
171 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
172 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 1 {{.*}} align 1 {{.*}}i64 3, i1 {{.*}})
anatofuz
parents:
diff changeset
173 // CHECK: ret %struct.BitfieldMember*
anatofuz
parents:
diff changeset
174
anatofuz
parents:
diff changeset
175 // InnerClass copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
176 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.InnerClassMember* @_ZN16InnerClassMemberaSERKS_(%struct.InnerClassMember* %this, %struct.InnerClassMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
177 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 32, i1 {{.*}})
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
178 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
179 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
180 // CHECK: ret %struct.InnerClassMember*
anatofuz
parents:
diff changeset
181
anatofuz
parents:
diff changeset
182 // PackedMembers copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
183 // CHECK-LABEL: define linkonce_odr nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.PackedMembers* @_ZN13PackedMembersaSERKS_(%struct.PackedMembers* %this, %struct.PackedMembers* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
184 // CHECK: call nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.NonPOD* @_ZN6NonPODaSERKS_
150
anatofuz
parents:
diff changeset
185 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 1 {{.*}} align 1 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
186 // CHECK: ret %struct.PackedMembers*
anatofuz
parents:
diff changeset
187
anatofuz
parents:
diff changeset
188 // COPY-CONSTRUCTORS:
anatofuz
parents:
diff changeset
189
anatofuz
parents:
diff changeset
190 // Clang outputs copy-constructors in the reverse of the order that
anatofuz
parents:
diff changeset
191 // copy-constructor calls are encountered. Add functions that call the copy
anatofuz
parents:
diff changeset
192 // constructors of the classes above in reverse order here.
anatofuz
parents:
diff changeset
193
anatofuz
parents:
diff changeset
194 #define CALL_CC(T) T callCC##T(const T& b) { return b; }
anatofuz
parents:
diff changeset
195
anatofuz
parents:
diff changeset
196 CALL_CC(PackedMembers)
anatofuz
parents:
diff changeset
197 // PackedMembers copy-assignment:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
198 // CHECK-LABEL: define linkonce_odr void @_ZN13PackedMembersC2ERKS_(%struct.PackedMembers* %this, %struct.PackedMembers* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
199 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
200 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 1 {{.*}} align 1 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
201 // CHECK: ret void
anatofuz
parents:
diff changeset
202
anatofuz
parents:
diff changeset
203 CALL_CC(BitfieldMember2)
anatofuz
parents:
diff changeset
204 // BitfieldMember2 copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
205 // CHECK-2-LABEL: define linkonce_odr void @_ZN15BitfieldMember2C2ERKS_(%struct.BitfieldMember2* %this, %struct.BitfieldMember2* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
206 // CHECK-2: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 false)
anatofuz
parents:
diff changeset
207 // CHECK-2: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
208 // CHECK-2: ret void
anatofuz
parents:
diff changeset
209
anatofuz
parents:
diff changeset
210 CALL_CC(BitfieldMember3)
anatofuz
parents:
diff changeset
211 // BitfieldMember3 copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
212 // CHECK-LABEL: define linkonce_odr void @_ZN15BitfieldMember3C2ERKS_(%struct.BitfieldMember3* %this, %struct.BitfieldMember3* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
213 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 8 {{.*}} align 8 {{.*}}i64 8, i1 false)
anatofuz
parents:
diff changeset
214 // CHECK: ret void
anatofuz
parents:
diff changeset
215
anatofuz
parents:
diff changeset
216 CALL_CC(ReferenceMember)
anatofuz
parents:
diff changeset
217 // ReferenceMember copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
218 // CHECK-LABEL: define linkonce_odr void @_ZN15ReferenceMemberC2ERKS_(%struct.ReferenceMember* %this, %struct.ReferenceMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
219 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 8 {{.*}} align 8 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
220 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
221 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 8 {{.*}} align 8 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
222 // CHECK: ret void
anatofuz
parents:
diff changeset
223
anatofuz
parents:
diff changeset
224 CALL_CC(InnerClassMember)
anatofuz
parents:
diff changeset
225 // InnerClass copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
226 // CHECK-LABEL: define linkonce_odr void @_ZN16InnerClassMemberC2ERKS_(%struct.InnerClassMember* %this, %struct.InnerClassMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
227 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 32, i1 {{.*}})
anatofuz
parents:
diff changeset
228 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
229 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
230 // CHECK: ret void
anatofuz
parents:
diff changeset
231
anatofuz
parents:
diff changeset
232 CALL_CC(BitfieldMember)
anatofuz
parents:
diff changeset
233 // BitfieldMember copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
234 // CHECK-LABEL: define linkonce_odr void @_ZN14BitfieldMemberC2ERKS_(%struct.BitfieldMember* %this, %struct.BitfieldMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
235 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
236 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
237 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 1 {{.*}} align 1 {{.*}}i64 3, i1 {{.*}})
anatofuz
parents:
diff changeset
238 // CHECK: ret void
anatofuz
parents:
diff changeset
239
anatofuz
parents:
diff changeset
240 CALL_CC(VolatileMember)
anatofuz
parents:
diff changeset
241 // VolatileMember copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
242 // CHECK-LABEL: define linkonce_odr void @_ZN14VolatileMemberC2ERKS_(%struct.VolatileMember* %this, %struct.VolatileMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
243 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
244 // CHECK: load volatile i32, i32* {{.*}}, align 4
anatofuz
parents:
diff changeset
245 // CHECK: store volatile i32 {{.*}}, align 4
anatofuz
parents:
diff changeset
246 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
247 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
248 // CHECK: ret void
anatofuz
parents:
diff changeset
249
anatofuz
parents:
diff changeset
250 CALL_CC(ArrayMember)
anatofuz
parents:
diff changeset
251 // ArrayMember copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
252 // CHECK-LABEL: define linkonce_odr void @_ZN11ArrayMemberC2ERKS_(%struct.ArrayMember* %this, %struct.ArrayMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
253 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 64, i1 {{.*}})
anatofuz
parents:
diff changeset
254 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
255 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 64, i1 {{.*}})
anatofuz
parents:
diff changeset
256 // CHECK: ret void
anatofuz
parents:
diff changeset
257
anatofuz
parents:
diff changeset
258 CALL_CC(PODLikeMember)
anatofuz
parents:
diff changeset
259 // PODLikeMember copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
260 // CHECK-LABEL: define linkonce_odr void @_ZN13PODLikeMemberC2ERKS_(%struct.PODLikeMember* %this, %struct.PODLikeMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
261 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 32, i1 {{.*}})
anatofuz
parents:
diff changeset
262 // CHECK: invoke void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
263 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
264 // CHECK: ret void
anatofuz
parents:
diff changeset
265 // CHECK: landingpad
anatofuz
parents:
diff changeset
266 // CHECK: invoke void @_ZN7PODLikeD1Ev
anatofuz
parents:
diff changeset
267
anatofuz
parents:
diff changeset
268 CALL_CC(PODMember)
anatofuz
parents:
diff changeset
269 // PODMember copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
270 // CHECK-LABEL: define linkonce_odr void @_ZN9PODMemberC2ERKS_(%struct.PODMember* %this, %struct.PODMember* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
271 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 32, i1 {{.*}})
anatofuz
parents:
diff changeset
272 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
273 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
274 // CHECK: ret void
anatofuz
parents:
diff changeset
275
anatofuz
parents:
diff changeset
276 CALL_CC(Basic)
anatofuz
parents:
diff changeset
277 // Basic copy-constructor:
173
0572611fdcc8 reorgnization done
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents: 150
diff changeset
278 // CHECK-LABEL: define linkonce_odr void @_ZN5BasicC2ERKS_(%struct.Basic* %this, %struct.Basic* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %0)
150
anatofuz
parents:
diff changeset
279 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
280 // CHECK: call void @_ZN6NonPODC1ERKS_
anatofuz
parents:
diff changeset
281 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64({{.*}} align 4 {{.*}} align 4 {{.*}}i64 16, i1 {{.*}})
anatofuz
parents:
diff changeset
282 // CHECK: ret void