maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGen/volatile.c

215 lines
7.1 KiB
C
Raw Normal View History

Complete Rewrite of CGRecordLayoutBuilder CGRecordLayoutBuilder was aging, complex, multi-pass, and shows signs of existing before ASTRecordLayoutBuilder. It redundantly performed many layout operations that are now performed by ASTRecordLayoutBuilder and asserted that the results were the same. With the addition of support for the MS-ABI, such as placement of vbptrs, vtordisps, different bitfield layout and a variety of other features, CGRecordLayoutBuilder was growing unwieldy in its redundancy. This patch re-architects CGRecordLayoutBuilder to not perform any redundant layout but rather, as directly as possible, lower an ASTRecordLayout to an llvm::type. The new architecture is significantly smaller and simpler than the CGRecordLayoutBuilder and contains fewer ABI-specific code paths. It's also one pass. The architecture of the new system is described in the comments. For the most part, the new system simply takes all of the fields and bases from an ASTRecordLayout, sorts them, inserts padding and dumps a record. Bitfields, unions and primary virtual bases make this process a bit more complicated. See the inline comments. In addition, this patch updates a few lit tests due to the fact that the new system computes more accurate llvm types than CGRecordLayoutBuilder. Each change is commented individually in the review. Differential Revision: http://llvm-reviews.chandlerc.com/D2795 llvm-svn: 201907
2014-02-22 07:49:50 +08:00
// RUN: %clang_cc1 -triple=%itanium_abi_triple -emit-llvm < %s | FileCheck %s -check-prefix CHECK -check-prefix CHECK-IT
// RUN: %clang_cc1 -triple=%ms_abi_triple -emit-llvm < %s | FileCheck %s -check-prefix CHECK -check-prefix CHECK-MS
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
int S;
volatile int vS;
int* pS;
volatile int* pvS;
int A[10];
volatile int vA[10];
struct { int x; } F;
struct { volatile int x; } vF;
struct { int x; } F2;
volatile struct { int x; } vF2;
volatile struct { int x; } *vpF2;
struct { struct { int y; } x; } F3;
volatile struct { struct { int y; } x; } vF3;
struct { int x:3; } BF;
struct { volatile int x:3; } vBF;
typedef int v4si __attribute__ ((vector_size (16)));
v4si V;
volatile v4si vV;
typedef __attribute__(( ext_vector_type(4) )) int extv4;
extv4 VE;
volatile extv4 vVE;
volatile struct {int x;} aggFct(void);
Test case for recent checkin. llvm-svn: 85972
2009-11-04 07:32:42 +08:00
typedef volatile int volatile_int;
volatile_int vtS;
Semantic checking for main(). Fix some invalid main() methods in the test suite that were nicely exposed by the new checks. llvm-svn: 77047
2009-07-25 12:36:53 +08:00
int main() {
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
int i;
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: [[I:%[a-zA-Z0-9_.]+]] = alloca i32
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
// load
i=S;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* @S
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vS;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* @vS
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=*pS;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[PS_VAL:%[a-zA-Z0-9_.]+]] = load i32*, i32** @pS
// CHECK: load i32, i32* [[PS_VAL]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=*pvS;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[PVS_VAL:%[a-zA-Z0-9_.]+]] = load i32*, i32** @pvS
// CHECK: load volatile i32, i32* [[PVS_VAL]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=A[2];
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* getelementptr {{.*}} @A
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vA[2];
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* getelementptr {{.*}} @vA
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=F.x;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* getelementptr {{.*}} @F
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vF.x;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* getelementptr {{.*}} @vF
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=F2.x;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* getelementptr {{.*}} @F2
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vF2.x;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* getelementptr {{.*}} @vF2
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vpF2->x;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[VPF2_VAL:%[a-zA-Z0-9_.]+]] = load {{%[a-zA-Z0-9_.]+}}*, {{%[a-zA-Z0-9_.]+}}** @vpF2
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: [[ELT:%[a-zA-Z0-9_.]+]] = getelementptr {{.*}} [[VPF2_VAL]]
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* [[ELT]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=F3.x.y;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* getelementptr {{.*}} @F3
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vF3.x.y;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* getelementptr {{.*}} @vF3
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=BF.x;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-IT: load i8, i8* getelementptr {{.*}} @BF
// CHECK-MS: load i32, i32* getelementptr {{.*}} @BF
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vBF.x;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-IT: load volatile i8, i8* getelementptr {{.*}} @vBF
// CHECK-MS: load volatile i32, i32* getelementptr {{.*}} @vBF
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=V[3];
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load <4 x i32>, <4 x i32>* @V
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vV[3];
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile <4 x i32>, <4 x i32>* @vV
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=VE.yx[1];
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load <4 x i32>, <4 x i32>* @VE
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i=vVE.zy[1];
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile <4 x i32>, <4 x i32>* @vVE
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
When forming a function call or message send expression, be sure to strip cv-qualifiers from the expression's type when the language calls for it: in C, that's all the time, while C++ only does it for non-class types. Centralized the computation of the call expression type in QualType::getCallResultType() and some helper functions in other nodes (FunctionDecl, ObjCMethodDecl, FunctionType), and updated all relevant callers of getResultType() to getCallResultType(). Fixes PR7598 and PR7463, along with a bunch of getResultType() call sites that weren't stripping references off the result type (nothing stripped cv-qualifiers properly before this change). llvm-svn: 108234
2010-07-13 16:18:22 +08:00
i = aggFct().x; // Note: not volatile
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// N.b. Aggregate return is extremely target specific, all we can
// really say here is that there probably shouldn't be a volatile
// load.
// CHECK-NOT: load volatile
// CHECK: store i32 {{.*}}, i32* [[I]]
Test case for recent checkin. llvm-svn: 85972
2009-11-04 07:32:42 +08:00
i=vtS;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* @vtS
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
// store
S=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* @S
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
vS=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* @vS
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
*pS=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
// CHECK: [[PS_VAL:%[a-zA-Z0-9_.]+]] = load i32*, i32** @pS
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[PS_VAL]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
*pvS=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
// CHECK: [[PVS_VAL:%[a-zA-Z0-9_.]+]] = load i32*, i32** @pvS
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* [[PVS_VAL]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
A[2]=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* getelementptr {{.*}} @A
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
vA[2]=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* getelementptr {{.*}} @vA
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
F.x=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* getelementptr {{.*}} @F
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
vF.x=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* getelementptr {{.*}} @vF
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
F2.x=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* getelementptr {{.*}} @F2
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
vF2.x=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* getelementptr {{.*}} @vF2
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
vpF2->x=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
// CHECK: [[VPF2_VAL:%[a-zA-Z0-9_.]+]] = load {{%[a-zA-Z0-9._]+}}*, {{%[a-zA-Z0-9._]+}}** @vpF2
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: [[ELT:%[a-zA-Z0-9_.]+]] = getelementptr {{.*}} [[VPF2_VAL]]
// CHECK: store volatile i32 {{.*}}, i32* [[ELT]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
vF3.x.y=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* getelementptr {{.*}} @vF3
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
BF.x=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
// CHECK-IT: load i8, i8* getelementptr {{.*}} @BF
// CHECK-MS: load i32, i32* getelementptr {{.*}} @BF
Complete Rewrite of CGRecordLayoutBuilder CGRecordLayoutBuilder was aging, complex, multi-pass, and shows signs of existing before ASTRecordLayoutBuilder. It redundantly performed many layout operations that are now performed by ASTRecordLayoutBuilder and asserted that the results were the same. With the addition of support for the MS-ABI, such as placement of vbptrs, vtordisps, different bitfield layout and a variety of other features, CGRecordLayoutBuilder was growing unwieldy in its redundancy. This patch re-architects CGRecordLayoutBuilder to not perform any redundant layout but rather, as directly as possible, lower an ASTRecordLayout to an llvm::type. The new architecture is significantly smaller and simpler than the CGRecordLayoutBuilder and contains fewer ABI-specific code paths. It's also one pass. The architecture of the new system is described in the comments. For the most part, the new system simply takes all of the fields and bases from an ASTRecordLayout, sorts them, inserts padding and dumps a record. Bitfields, unions and primary virtual bases make this process a bit more complicated. See the inline comments. In addition, this patch updates a few lit tests due to the fact that the new system computes more accurate llvm types than CGRecordLayoutBuilder. Each change is commented individually in the review. Differential Revision: http://llvm-reviews.chandlerc.com/D2795 llvm-svn: 201907
2014-02-22 07:49:50 +08:00
// CHECK-IT: store i8 {{.*}}, i8* getelementptr {{.*}} @BF
// CHECK-MS: store i32 {{.*}}, i32* getelementptr {{.*}} @BF
Fix redundant load of bit-fields on assignment (to get the updated value). - Use extra argument to EmitStoreThroughLValue to provide place to write update bit-field value if caller requires it. - This fixes several FIXMEs. llvm-svn: 59615
2008-11-19 17:36:46 +08:00
vBF.x=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
// CHECK-IT: load volatile i8, i8* getelementptr {{.*}} @vBF
// CHECK-MS: load volatile i32, i32* getelementptr {{.*}} @vBF
Complete Rewrite of CGRecordLayoutBuilder CGRecordLayoutBuilder was aging, complex, multi-pass, and shows signs of existing before ASTRecordLayoutBuilder. It redundantly performed many layout operations that are now performed by ASTRecordLayoutBuilder and asserted that the results were the same. With the addition of support for the MS-ABI, such as placement of vbptrs, vtordisps, different bitfield layout and a variety of other features, CGRecordLayoutBuilder was growing unwieldy in its redundancy. This patch re-architects CGRecordLayoutBuilder to not perform any redundant layout but rather, as directly as possible, lower an ASTRecordLayout to an llvm::type. The new architecture is significantly smaller and simpler than the CGRecordLayoutBuilder and contains fewer ABI-specific code paths. It's also one pass. The architecture of the new system is described in the comments. For the most part, the new system simply takes all of the fields and bases from an ASTRecordLayout, sorts them, inserts padding and dumps a record. Bitfields, unions and primary virtual bases make this process a bit more complicated. See the inline comments. In addition, this patch updates a few lit tests due to the fact that the new system computes more accurate llvm types than CGRecordLayoutBuilder. Each change is commented individually in the review. Differential Revision: http://llvm-reviews.chandlerc.com/D2795 llvm-svn: 201907
2014-02-22 07:49:50 +08:00
// CHECK-IT: store volatile i8 {{.*}}, i8* getelementptr {{.*}} @vBF
// CHECK-MS: store volatile i32 {{.*}}, i32* getelementptr {{.*}} @vBF
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
V[3]=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
// CHECK: load <4 x i32>, <4 x i32>* @V
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store <4 x i32> {{.*}}, <4 x i32>* @V
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
vV[3]=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
// CHECK: load volatile <4 x i32>, <4 x i32>* @vV
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile <4 x i32> {{.*}}, <4 x i32>* @vV
Test case for recent checkin. llvm-svn: 85972
2009-11-04 07:32:42 +08:00
vtS=i;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* @vtS
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
// other ops:
++S;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* @S
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* @S
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
++vS;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* @vS
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* @vS
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i+=S;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i32, i32* @S
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
i+=vS;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* @vS
// CHECK: load i32, i32* [[I]]
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store i32 {{.*}}, i32* [[I]]
Test case for recent checkin. llvm-svn: 85972
2009-11-04 07:32:42 +08:00
++vtS;
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load volatile i32, i32* @vtS
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: store volatile i32 {{.*}}, i32* @vtS
Fixup codegen for volatile structs in the trivial cases (a a=a and a=a=a). llvm-svn: 72439
2009-05-27 06:03:21 +08:00
(void)vF2;
FileCheckize volatile test llvm-svn: 174627
2013-02-07 23:39:16 +08:00
// From vF2 to a temporary
Change memcpy/memset/memmove to have dest and source alignments. This is a follow on from a similar LLVM commit: r253511. Note, this was reviewed (and more details are in) http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20151109/312083.html These intrinsics currently have an explicit alignment argument which is required to be a constant integer. It represents the alignment of the source and dest, and so must be the minimum of those. This change allows source and dest to each have their own alignments by using the alignment attribute on their arguments. The alignment argument itself is removed. The only code change to clang is hidden in CGBuilder.h which now passes both dest and source alignment to IRBuilder, instead of taking the minimum of dest and source alignments. Reviewed by Hal Finkel. llvm-svn: 253512
2015-11-19 06:18:45 +08:00
// CHECK: call void @llvm.memcpy.{{.*}}(i8* align {{[0-9]*}} %{{[0-9]*}}, i8* align {{[0-9]*}} {{.*@vF2.*}}, i{{[0-9]*}} {{[0-9]*}}, i1 true)
Fixup codegen for volatile structs in the trivial cases (a a=a and a=a=a). llvm-svn: 72439
2009-05-27 06:03:21 +08:00
vF2 = vF2;
FileCheckize volatile test llvm-svn: 174627
2013-02-07 23:39:16 +08:00
// vF2 to itself
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: call void @llvm.memcpy.{{.*}}(i8* {{.*@vF2.*}}, i8* {{.*@vF2.*}}, i1 true)
Fixup codegen for volatile structs in the trivial cases (a a=a and a=a=a). llvm-svn: 72439
2009-05-27 06:03:21 +08:00
vF2 = vF2 = vF2;
FileCheckize volatile test llvm-svn: 174627
2013-02-07 23:39:16 +08:00
// vF2 to itself twice
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: call void @llvm.memcpy.{{.*}}(i8* {{.*@vF2.*}}, i8* {{.*@vF2.*}}, i1 true)
// CHECK: call void @llvm.memcpy.{{.*}}(i8* {{.*@vF2.*}}, i8* {{.*@vF2.*}}, i1 true)
Revert r112043, static volatiles are removed by the optimizer. Thanks Chris! llvm-svn: 112112
2010-08-26 07:42:51 +08:00
vF2 = (vF2, vF2);
FileCheckize volatile test llvm-svn: 174627
2013-02-07 23:39:16 +08:00
// vF2 to a temporary, then vF2 to itself
Change memcpy/memset/memmove to have dest and source alignments. This is a follow on from a similar LLVM commit: r253511. Note, this was reviewed (and more details are in) http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20151109/312083.html These intrinsics currently have an explicit alignment argument which is required to be a constant integer. It represents the alignment of the source and dest, and so must be the minimum of those. This change allows source and dest to each have their own alignments by using the alignment attribute on their arguments. The alignment argument itself is removed. The only code change to clang is hidden in CGBuilder.h which now passes both dest and source alignment to IRBuilder, instead of taking the minimum of dest and source alignments. Reviewed by Hal Finkel. llvm-svn: 253512
2015-11-19 06:18:45 +08:00
// CHECK: call void @llvm.memcpy.{{.*}}(i8* align {{[0-9]*}} %{{[0-9]*}}, i8* align {{[0-9]*}} {{.*@vF2.*}}, i{{[0-9]*}} {{[0-9]*}}, i1 true)
Improve filechecking of volatile test. My previous attempt was extremely deficient, allowing more volatiles to be introduced and not even checking all of the ones that are present. This attempt doesn't try to keep track of the values stored or offsets within particular objects, just that the correct objects are accessed in a correctly volatile manner throughout. llvm-svn: 174700
2013-02-08 16:00:13 +08:00
// CHECK: call void @llvm.memcpy.{{.*}}(i8* {{.*@vF2.*}}, i8* {{.*@vF2.*}}, i1 true)
Basic support for volatile loads and stores. Stores the volatile qualifier in the lvalue, and changes lvalue loads/stores to honor the volatile flag. Places which need some further attention are marked with FIXMEs. Patch by Cédric Venet. llvm-svn: 52264
2008-06-14 07:01:12 +08:00
}