Mercurial > hg > CbC > CbC_llvm

comparison clang/test/Modules/compare-record.c @ 252:1f2b6ac9f198 llvm-original

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM16-1
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Fri, 18 Aug 2023 09:04:13 +0900
parents
children
comparison
equal deleted inserted replaced
237:c80f45b162ad 252:1f2b6ac9f198
1 // RUN: rm -rf %t
2 // RUN: split-file %s %t
3
4 // Build first header file
5 // RUN: echo "#define FIRST" >> %t/include/first.h
6 // RUN: cat %t/test.c >> %t/include/first.h
7 // RUN: echo "#undef FIRST" >> %t/include/first.h
8
9 // Build second header file
10 // RUN: echo "#define SECOND" >> %t/include/second.h
11 // RUN: cat %t/test.c >> %t/include/second.h
12 // RUN: echo "#undef SECOND" >> %t/include/second.h
13
14 // Test that each header can compile
15 // RUN: %clang_cc1 -fsyntax-only -x objective-c %t/include/first.h -fblocks -fobjc-arc
16 // RUN: %clang_cc1 -fsyntax-only -x objective-c %t/include/second.h -fblocks -fobjc-arc
17
18 // Run test
19 // RUN: %clang_cc1 -I%t/include -verify %t/test.c -fblocks -fobjc-arc \
20 // RUN: -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/modules.cache
21
22 // Run tests for nested structs
23 // DEFINE: %{filename} = test-nested-struct.c
24 // DEFINE: %{macro_flag} = -DCASE1=1
25 // DEFINE: %{command} = %clang_cc1 -I%t/include -verify %t/%{filename} -fblocks -fobjc-arc \
26 // DEFINE: -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/modules.cache \
27 // DEFINE: %{macro_flag} -emit-llvm -o %t/%{filename}.bc
28 // RUN: %{command}
29 // REDEFINE: %{macro_flag} = -DCASE2=1
30 // RUN: %{command}
31 // REDEFINE: %{macro_flag} = -DCASE3=1
32 // RUN: %{command}
33
34 // Run tests for anonymous nested structs and unions
35 // REDEFINE: %{filename} = test-anonymous.c
36 // REDEFINE: %{macro_flag} = -DCASE1=1
37 // RUN: %{command}
38 // REDEFINE: %{macro_flag} = -DCASE2=1
39 // RUN: %{command}
40 // REDEFINE: %{macro_flag} = -DCASE3=1
41 // RUN: %{command}
42
43 // Test that we don't accept different structs and unions with the same name
44 // from multiple modules but detect mismatches and provide actionable
45 // diagnostic.
46
47 //--- include/first-empty.h
48 //--- include/module.modulemap
49 module First {
50 module Empty {
51 header "first-empty.h"
52 }
53 module Hidden {
54 header "first.h"
55 header "first-nested-struct.h"
56 header "first-anonymous.h"
57 export *
58 }
59 }
60 module Second {
61 header "second.h"
62 header "second-nested-struct.h"
63 header "second-anonymous.h"
64 export *
65 }
66
67 //--- test.c
68 #if !defined(FIRST) && !defined(SECOND)
69 # include "first-empty.h"
70 # include "second.h"
71 #endif
72
73 #if defined(FIRST)
74 struct CompareForwardDeclaration1;
75 struct CompareForwardDeclaration2 {};
76 #elif defined(SECOND)
77 struct CompareForwardDeclaration1 {};
78 struct CompareForwardDeclaration2;
79 #else
80 struct CompareForwardDeclaration1 *compareForwardDeclaration1;
81 struct CompareForwardDeclaration2 *compareForwardDeclaration2;
82 #endif
83
84 #if defined(FIRST)
85 struct CompareMatchingFields {
86 int matchingFieldName;
87 };
88
89 struct CompareFieldPresence1 {
90 int fieldPresence1;
91 };
92 struct CompareFieldPresence2 {};
93
94 struct CompareFieldName {
95 int fieldNameA;
96 };
97
98 struct CompareFieldOrder {
99 int fieldOrderX;
100 int fieldOrderY;
101 };
102 #elif defined(SECOND)
103 struct CompareMatchingFields {
104 int matchingFieldName;
105 };
106
107 struct CompareFieldPresence1 {
108 };
109 struct CompareFieldPresence2 {
110 int fieldPresence2;
111 };
112
113 struct CompareFieldName {
114 int fieldNameB;
115 };
116
117 struct CompareFieldOrder {
118 int fieldOrderY;
119 int fieldOrderX;
120 };
121 #else
122 struct CompareMatchingFields compareMatchingFields;
123 struct CompareFieldPresence1 compareFieldPresence1;
124 // expected-error@first.h:* {{'CompareFieldPresence1' has different definitions in different modules; first difference is definition in module 'First.Hidden' found field}}
125 // expected-note@second.h:* {{but in 'Second' found end of class}}
126 struct CompareFieldPresence2 compareFieldPresence2;
127 // expected-error@second.h:* {{'CompareFieldPresence2::fieldPresence2' from module 'Second' is not present in definition of 'struct CompareFieldPresence2' in module 'First.Hidden'}}
128 // expected-note@first.h:* {{definition has no member 'fieldPresence2'}}
129 struct CompareFieldName compareFieldName;
130 // expected-error@second.h:* {{'CompareFieldName::fieldNameB' from module 'Second' is not present in definition of 'struct CompareFieldName' in module 'First.Hidden'}}
131 // expected-note@first.h:* {{definition has no member 'fieldNameB'}}
132 struct CompareFieldOrder compareFieldOrder;
133 // expected-error@first.h:* {{'CompareFieldOrder' has different definitions in different modules; first difference is definition in module 'First.Hidden' found field 'fieldOrderX'}}
134 // expected-note@second.h:* {{but in 'Second' found field 'fieldOrderY'}}
135 #endif
136
137 #if defined(FIRST)
138 struct CompareFieldType {
139 int fieldType;
140 };
141
142 typedef int FieldTypedefNameA;
143 struct CompareFieldTypedefName {
144 FieldTypedefNameA fieldTypedefName;
145 };
146
147 typedef int TypedefUnderlyingType;
148 struct CompareFieldTypeUnderlyingTypedef {
149 TypedefUnderlyingType fieldTypeUnderlyingTypedef;
150 };
151
152 typedef int TypedefFinal;
153 struct CompareFieldTypedefChain {
154 TypedefFinal fieldTypeTypedefChain;
155 };
156 #elif defined(SECOND)
157 struct CompareFieldType {
158 float fieldType;
159 };
160
161 typedef int FieldTypedefNameB;
162 struct CompareFieldTypedefName {
163 FieldTypedefNameB fieldTypedefName;
164 };
165
166 struct CompareFieldTypeUnderlyingTypedef {
167 int fieldTypeUnderlyingTypedef;
168 };
169
170 typedef int TypedefIntermediate;
171 typedef TypedefIntermediate TypedefFinal;
172 struct CompareFieldTypedefChain {
173 TypedefFinal fieldTypeTypedefChain;
174 };
175 #else
176 struct CompareFieldType compareFieldType;
177 // expected-error@second.h:* {{'CompareFieldType::fieldType' from module 'Second' is not present in definition of 'struct CompareFieldType' in module 'First.Hidden'}}
178 // expected-note@first.h:* {{declaration of 'fieldType' does not match}}
179 struct CompareFieldTypedefName compareFieldTypedefName;
180 // expected-error@first.h:* {{'CompareFieldTypedefName' has different definitions in different modules; first difference is definition in module 'First.Hidden' found field 'fieldTypedefName' with type 'FieldTypedefNameA' (aka 'int')}}
181 // expected-note@second.h:* {{but in 'Second' found field 'fieldTypedefName' with type 'FieldTypedefNameB' (aka 'int')}}
182 struct CompareFieldTypeUnderlyingTypedef compareFieldTypeUnderlyingTypedef;
183 // expected-error@first.h:* {{'CompareFieldTypeUnderlyingTypedef' has different definitions in different modules; first difference is definition in module 'First.Hidden' found field 'fieldTypeUnderlyingTypedef' with type 'TypedefUnderlyingType' (aka 'int')}}
184 // expected-note@second.h:* {{but in 'Second' found field 'fieldTypeUnderlyingTypedef' with type 'int'}}
185 struct CompareFieldTypedefChain compareFieldTypedefChain;
186 #endif
187
188 #if defined(FIRST)
189 struct CompareMatchingBitfields {
190 unsigned matchingBitfields : 3;
191 };
192
193 struct CompareBitfieldPresence1 {
194 unsigned bitfieldPresence1 : 1;
195 };
196 struct CompareBitfieldPresence2 {
197 unsigned bitfieldPresence2;
198 };
199
200 struct CompareBitfieldWidth {
201 unsigned bitfieldWidth : 2;
202 };
203
204 struct CompareBitfieldWidthExpression {
205 unsigned bitfieldWidthExpression : 1 + 1;
206 };
207 #elif defined(SECOND)
208 struct CompareMatchingBitfields {
209 unsigned matchingBitfields : 3;
210 };
211
212 struct CompareBitfieldPresence1 {
213 unsigned bitfieldPresence1;
214 };
215 struct CompareBitfieldPresence2 {
216 unsigned bitfieldPresence2 : 1;
217 };
218
219 struct CompareBitfieldWidth {
220 unsigned bitfieldWidth : 1;
221 };
222
223 struct CompareBitfieldWidthExpression {
224 unsigned bitfieldWidthExpression : 2;
225 };
226 #else
227 struct CompareMatchingBitfields compareMatchingBitfields;
228 struct CompareBitfieldPresence1 compareBitfieldPresence1;
229 // expected-error@first.h:* {{'CompareBitfieldPresence1' has different definitions in different modules; first difference is definition in module 'First.Hidden' found bitfield 'bitfieldPresence1'}}
230 // expected-note@second.h:* {{but in 'Second' found non-bitfield 'bitfieldPresence1'}}
231 struct CompareBitfieldPresence2 compareBitfieldPresence2;
232 // expected-error@first.h:* {{'CompareBitfieldPresence2' has different definitions in different modules; first difference is definition in module 'First.Hidden' found non-bitfield 'bitfieldPresence2'}}
233 // expected-note@second.h:* {{but in 'Second' found bitfield 'bitfieldPresence2'}}
234 struct CompareBitfieldWidth compareBitfieldWidth;
235 // expected-error@first.h:* {{'CompareBitfieldWidth' has different definitions in different modules; first difference is definition in module 'First.Hidden' found bitfield 'bitfieldWidth' with one width expression}}
236 // expected-note@second.h:* {{but in 'Second' found bitfield 'bitfieldWidth' with different width expression}}
237 struct CompareBitfieldWidthExpression compareBitfieldWidthExpression;
238 // expected-error@first.h:* {{'CompareBitfieldWidthExpression' has different definitions in different modules; first difference is definition in module 'First.Hidden' found bitfield 'bitfieldWidthExpression' with one width expression}}
239 // expected-note@second.h:* {{but in 'Second' found bitfield 'bitfieldWidthExpression' with different width expressio}}
240 #endif
241
242 #if defined(FIRST)
243 struct CompareMatchingArrayFields {
244 int matchingArrayField[7];
245 };
246
247 struct CompareArrayLength {
248 int arrayLengthField[5];
249 };
250
251 struct CompareArrayType {
252 int arrayTypeField[5];
253 };
254 #elif defined(SECOND)
255 struct CompareMatchingArrayFields {
256 int matchingArrayField[7];
257 };
258
259 struct CompareArrayLength {
260 int arrayLengthField[7];
261 };
262
263 struct CompareArrayType {
264 float arrayTypeField[5];
265 };
266 #else
267 struct CompareMatchingArrayFields compareMatchingArrayFields;
268 struct CompareArrayLength compareArrayLength;
269 // expected-error@second.h:* {{'CompareArrayLength::arrayLengthField' from module 'Second' is not present in definition of 'struct CompareArrayLength' in module 'First.Hidden'}}
270 // expected-note@first.h:* {{declaration of 'arrayLengthField' does not match}}
271 struct CompareArrayType compareArrayType;
272 // expected-error@second.h:* {{'CompareArrayType::arrayTypeField' from module 'Second' is not present in definition of 'struct CompareArrayType' in module 'First.Hidden'}}
273 // expected-note@first.h:* {{declaration of 'arrayTypeField' does not match}}
274 #endif
275
276 #if defined(FIRST)
277 struct CompareFieldAsForwardDeclaration {
278 struct FieldForwardDeclaration *fieldForwardDeclaration;
279 };
280
281 enum FieldEnumA { kFieldEnumValue };
282 struct CompareFieldAsEnum {
283 enum FieldEnumA fieldEnum;
284 };
285
286 struct FieldStructA {};
287 struct CompareFieldAsStruct {
288 struct FieldStructA fieldStruct;
289 };
290 #elif defined(SECOND)
291 struct FieldForwardDeclaration {};
292 struct CompareFieldAsForwardDeclaration {
293 struct FieldForwardDeclaration *fieldForwardDeclaration;
294 };
295
296 enum FieldEnumB { kFieldEnumValue };
297 struct CompareFieldAsEnum {
298 enum FieldEnumB fieldEnum;
299 };
300
301 struct FieldStructB {};
302 struct CompareFieldAsStruct {
303 struct FieldStructB fieldStruct;
304 };
305 #else
306 struct CompareFieldAsForwardDeclaration compareFieldAsForwardDeclaration;
307 struct CompareFieldAsEnum compareFieldAsEnum;
308 // expected-error@second.h:* {{'CompareFieldAsEnum::fieldEnum' from module 'Second' is not present in definition of 'struct CompareFieldAsEnum' in module 'First.Hidden'}}
309 // expected-note@first.h:* {{declaration of 'fieldEnum' does not match}}
310 struct CompareFieldAsStruct compareFieldAsStruct;
311 // expected-error@second.h:* {{'CompareFieldAsStruct::fieldStruct' from module 'Second' is not present in definition of 'struct CompareFieldAsStruct' in module 'First.Hidden'}}
312 // expected-note@first.h:* {{declaration of 'fieldStruct' does not match}}
313 #endif
314
315 #if defined(FIRST)
316 union CompareMatchingUnionFields {
317 int matchingFieldA;
318 float matchingFieldB;
319 };
320
321 union CompareUnionFieldOrder {
322 int unionFieldOrderA;
323 float unionFieldOrderB;
324 };
325
326 union CompareUnionFieldType {
327 int unionFieldType;
328 };
329 #elif defined(SECOND)
330 union CompareMatchingUnionFields {
331 int matchingFieldA;
332 float matchingFieldB;
333 };
334
335 union CompareUnionFieldOrder {
336 float unionFieldOrderB;
337 int unionFieldOrderA;
338 };
339
340 union CompareUnionFieldType {
341 unsigned int unionFieldType;
342 };
343 #else
344 union CompareMatchingUnionFields compareMatchingUnionFields;
345 union CompareUnionFieldOrder compareUnionFieldOrder;
346 // expected-error@first.h:* {{'CompareUnionFieldOrder' has different definitions in different modules; first difference is definition in module 'First.Hidden' found field 'unionFieldOrderA'}}
347 // expected-note@second.h:* {{but in 'Second' found field 'unionFieldOrderB'}}
348 union CompareUnionFieldType compareUnionFieldType;
349 // expected-error@second.h:* {{'CompareUnionFieldType::unionFieldType' from module 'Second' is not present in definition of 'union CompareUnionFieldType' in module 'First.Hidden'}}
350 // expected-note@first.h:* {{declaration of 'unionFieldType' does not match}}
351 #endif
352
353 // Test that we find and compare definitions even if they are not the first encountered declaration in a module.
354 #if defined(FIRST)
355 struct CompareDefinitionsRegardlessForwardDeclarations {
356 int definitionField;
357 };
358 #elif defined(SECOND)
359 struct CompareDefinitionsRegardlessForwardDeclarations;
360 struct CompareDefinitionsRegardlessForwardDeclarations {
361 float definitionField;
362 };
363 #else
364 struct CompareDefinitionsRegardlessForwardDeclarations compareDefinitions;
365 // expected-error@second.h:* {{'CompareDefinitionsRegardlessForwardDeclarations::definitionField' from module 'Second' is not present in definition of 'struct CompareDefinitionsRegardlessForwardDeclarations' in module 'First.Hidden'}}
366 // expected-note@first.h:* {{declaration of 'definitionField' does not match}}
367 #endif
368
369 //--- include/first-nested-struct.h
370 struct CompareNestedStruct {
371 struct NestedLevel1 {
372 struct NestedLevel2 {
373 int a;
374 } y;
375 } x;
376 };
377
378 struct IndirectStruct {
379 int mismatchingField;
380 };
381 struct DirectStruct {
382 struct IndirectStruct indirectField;
383 };
384 struct CompareDifferentFieldInIndirectStruct {
385 struct DirectStruct directField;
386 };
387 struct CompareIndirectStructPointer {
388 struct DirectStruct *directFieldPointer;
389 };
390
391 //--- include/second-nested-struct.h
392 struct CompareNestedStruct {
393 struct NestedLevel1 {
394 struct NestedLevel2 {
395 float b;
396 } y;
397 } x;
398 };
399
400 struct IndirectStruct {
401 float mismatchingField;
402 };
403 struct DirectStruct {
404 struct IndirectStruct indirectField;
405 };
406 struct CompareDifferentFieldInIndirectStruct {
407 struct DirectStruct directField;
408 };
409 struct CompareIndirectStructPointer {
410 struct DirectStruct *directFieldPointer;
411 };
412
413 //--- test-nested-struct.c
414 #include "first-empty.h"
415 #include "second-nested-struct.h"
416
417 #if defined(CASE1)
418 struct CompareNestedStruct compareNestedStruct;
419 // expected-error@second-nested-struct.h:* {{'NestedLevel2::b' from module 'Second' is not present in definition of 'struct NestedLevel2' in module 'First.Hidden'}}
420 // expected-note@first-nested-struct.h:* {{definition has no member 'b'}}
421 #elif defined(CASE2)
422 struct CompareDifferentFieldInIndirectStruct compareIndirectStruct;
423 // expected-error@second-nested-struct.h:* {{'IndirectStruct::mismatchingField' from module 'Second' is not present in definition of 'struct IndirectStruct' in module 'First.Hidden'}}
424 // expected-note@first-nested-struct.h:* {{declaration of 'mismatchingField' does not match}}
425 #elif defined(CASE3)
426 // expected-error@second-nested-struct.h:* {{'IndirectStruct::mismatchingField' from module 'Second' is not present in definition of 'struct IndirectStruct' in module 'First.Hidden'}}
427 // expected-note@first-nested-struct.h:* {{declaration of 'mismatchingField' does not match}}
428 struct CompareIndirectStructPointer compareIndirectStructPointer;
429 struct DirectStruct test() {
430 // Make sure the type behind the pointer is inspected.
431 return *compareIndirectStructPointer.directFieldPointer;
432 }
433 #endif
434
435 //--- include/first-anonymous.h
436 struct CompareAnonymousNestedUnion {
437 union {
438 int anonymousNestedUnionField;
439 };
440 };
441
442 struct CompareAnonymousNestedStruct {
443 struct {
444 int anonymousNestedStructField;
445 };
446 };
447
448 struct CompareDeeplyNestedAnonymousUnionsAndStructs {
449 union {
450 int x;
451 union {
452 int y;
453 struct {
454 int z;
455 };
456 };
457 };
458 };
459
460 //--- include/second-anonymous.h
461 struct CompareAnonymousNestedUnion {
462 union {
463 float anonymousNestedUnionField;
464 };
465 };
466
467 struct CompareAnonymousNestedStruct {
468 struct {
469 float anonymousNestedStructField;
470 };
471 };
472
473 struct CompareDeeplyNestedAnonymousUnionsAndStructs {
474 union {
475 int x;
476 union {
477 int y;
478 struct {
479 float z;
480 };
481 };
482 };
483 };
484
485 //--- test-anonymous.c
486 #include "first-empty.h"
487 #include "second-anonymous.h"
488
489 #if defined(CASE1)
490 struct CompareAnonymousNestedUnion compareAnonymousNestedUnion;
491 // expected-error-re@second-anonymous.h:* {{'CompareAnonymousNestedUnion::(anonymous union)::anonymousNestedUnionField' from module 'Second' is not present in definition of 'union CompareAnonymousNestedUnion::(anonymous at {{.*}})' in module 'First.Hidden'}}
492 // expected-note@first-anonymous.h:* {{declaration of 'anonymousNestedUnionField' does not match}}
493 #elif defined(CASE2)
494 struct CompareAnonymousNestedStruct compareAnonymousNestedStruct;
495 // expected-error-re@second-anonymous.h:* {{'CompareAnonymousNestedStruct::(anonymous struct)::anonymousNestedStructField' from module 'Second' is not present in definition of 'struct CompareAnonymousNestedStruct::(anonymous at {{.*}})' in module 'First.Hidden'}}
496 // expected-note@first-anonymous.h:* {{declaration of 'anonymousNestedStructField' does not match}}
497 #elif defined(CASE3)
498 struct CompareDeeplyNestedAnonymousUnionsAndStructs compareDeeplyNested;
499 // expected-error-re@second-anonymous.h:* {{'CompareDeeplyNestedAnonymousUnionsAndStructs::(anonymous union)::(anonymous union)::(anonymous struct)::z' from module 'Second' is not present in definition of 'struct CompareDeeplyNestedAnonymousUnionsAndStructs::(anonymous at {{.*}})' in module 'First.Hidden'}}
500 // expected-note@first-anonymous.h:* {{declaration of 'z' does not match}}
501 #endif