mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-17 06:56:44 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/clang/test/SemaOpenACC/update-construct-ast.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

374 lines
15 KiB
C++
Raw Normal View History

[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
// RUN: %clang_cc1 %s -fopenacc -ast-dump | FileCheck %s
// Test this with PCH.
// RUN: %clang_cc1 %s -fopenacc -emit-pch -o %t %s
// RUN: %clang_cc1 %s -fopenacc -include-pch %t -ast-dump-all | FileCheck %s
#ifndef PCH_HELPER
#define PCH_HELPER
[OpenACC] Enable 'if' and 'if_present' for 'update' construct The only restriction on 'if' is that only 1 can appear on an update construct, so this enforces that. 'if_present' has no restrictions.
2025-01-07 08:19:31 -08:00
int some_int();
long some_long();
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
int Global;
short GlobalArray[5];
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
void NormalFunc() {
// CHECK-LABEL: NormalFunc
// CHECK-NEXT: CompoundStmt
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(Global) if_present if (some_int() < some_long())
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
[OpenACC] Enable 'if' and 'if_present' for 'update' construct The only restriction on 'if' is that only 1 can appear on an update construct, so this enforces that. 'if_present' has no restrictions.
2025-01-07 08:19:31 -08:00
// CHECK-NEXT: if_present clause
// CHECK-NEXT: if clause
// CHECK-NEXT: BinaryOperator{{.*}}'bool' '<'
// CHECK-NEXT: ImplicitCastExpr{{.*}}'long'
// CHECK-NEXT: CallExpr{{.*}}'int'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_int' 'int ()'
// CHECK-NEXT: CallExpr{{.*}} 'long'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_long' 'long ()'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
[OpenACC] Start enforcing 'device_type' clause values Researching in prep of doing the implementation for lowering, I found that the source of the valid identifiers list from flang is in the frontend. This patch adds the same list to the frontend, but does it as a sema diagnostic, so we still parse it as an identifier/identifier-like thing, but then diagnose it as invalid later.
2025-04-09 14:20:15 -07:00
#pragma acc update self(Global) wait async device_type(nvidia) dtype(radeon)
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: async clause
[OpenACC] Start enforcing 'device_type' clause values Researching in prep of doing the implementation for lowering, I found that the source of the valid identifiers list from flang is in the frontend. This patch adds the same list to the frontend, but does it as a sema diagnostic, so we still parse it as an identifier/identifier-like thing, but then diagnose it as invalid later.
2025-04-09 14:20:15 -07:00
// CHECK-NEXT: device_type(nvidia)
// CHECK-NEXT: dtype(radeon)
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(Global) wait(some_int(), some_long()) async(some_int())
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: CallExpr{{.*}}'int'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_int' 'int ()'
// CHECK-NEXT: CallExpr{{.*}}'long'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_long' 'long ()'
// CHECK-NEXT: async clause
// CHECK-NEXT: CallExpr{{.*}}'int'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_int' 'int ()'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(Global) wait(queues:some_int(), some_long())
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: CallExpr{{.*}}'int'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_int' 'int ()'
// CHECK-NEXT: CallExpr{{.*}}'long'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_long' 'long ()'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(Global) wait(devnum: some_int() :some_int(), some_long())
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: CallExpr{{.*}}'int'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_int' 'int ()'
// CHECK-NEXT: CallExpr{{.*}}'int'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_int' 'int ()'
// CHECK-NEXT: CallExpr{{.*}}'long'
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'some_long' 'long ()'
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
#pragma acc update self(Global, GlobalArray, GlobalArray[0], GlobalArray[0:1])
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
// CHECK-NEXT: ArraySubscriptExpr{{.*}} 'short' lvalue
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
#pragma acc update host(Global, GlobalArray, GlobalArray[0], GlobalArray[0:1]) device(Global, GlobalArray, GlobalArray[0], GlobalArray[0:1])
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
// CHECK-NEXT: host clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
// CHECK-NEXT: ArraySubscriptExpr{{.*}} 'short' lvalue
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: device clause
// CHECK-NEXT: DeclRefExpr{{.*}}'Global' 'int'
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
// CHECK-NEXT: ArraySubscriptExpr{{.*}} 'short' lvalue
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}}'GlobalArray' 'short[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}} 'int' 1
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
}
template<typename T>
void TemplFunc(T t) {
// CHECK-LABEL: FunctionTemplateDecl {{.*}}TemplFunc
// CHECK-NEXT: TemplateTypeParmDecl
// CHECK-NEXT: FunctionDecl{{.*}}TemplFunc
// CHECK-NEXT: ParmVarDecl{{.*}} t 'T'
// CHECK-NEXT: CompoundStmt
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(t) if_present if (T::value < t)
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
[OpenACC] Enable 'if' and 'if_present' for 'update' construct The only restriction on 'if' is that only 1 can appear on an update construct, so this enforces that. 'if_present' has no restrictions.
2025-01-07 08:19:31 -08:00
// CHECK-NEXT: if_present clause
// CHECK-NEXT: if clause
// CHECK-NEXT: BinaryOperator{{.*}}'<dependent type>' '<'
// CHECK-NEXT: DependentScopeDeclRefExpr{{.*}} '<dependent type>'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'T'
// CHECK-NEXT: DeclRefExpr{{.*}}'t' 'T'
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
[OpenACC] Start enforcing 'device_type' clause values Researching in prep of doing the implementation for lowering, I found that the source of the valid identifiers list from flang is in the frontend. This patch adds the same list to the frontend, but does it as a sema diagnostic, so we still parse it as an identifier/identifier-like thing, but then diagnose it as invalid later.
2025-04-09 14:20:15 -07:00
#pragma acc update self(t) wait async device_type(default) dtype(host)
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: async clause
[OpenACC] Start enforcing 'device_type' clause values Researching in prep of doing the implementation for lowering, I found that the source of the valid identifiers list from flang is in the frontend. This patch adds the same list to the frontend, but does it as a sema diagnostic, so we still parse it as an identifier/identifier-like thing, but then diagnose it as invalid later.
2025-04-09 14:20:15 -07:00
// CHECK-NEXT: device_type(default)
// CHECK-NEXT: dtype(host)
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(t) wait(T::value, t) async(T::value)
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: DependentScopeDeclRefExpr{{.*}}'<dependent type>'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'T'
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
// CHECK-NEXT: async clause
// CHECK-NEXT: DependentScopeDeclRefExpr{{.*}}'<dependent type>'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'T'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(t) wait(queues:T::value, t) async(t)
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: DependentScopeDeclRefExpr{{.*}}'<dependent type>'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'T'
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
// CHECK-NEXT: async clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
#pragma acc update self(t) wait(devnum: T::value:t, T::value)
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: DependentScopeDeclRefExpr{{.*}}'<dependent type>'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'T'
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'T'
// CHECK-NEXT: DependentScopeDeclRefExpr{{.*}}'<dependent type>'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'T'
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
decltype(T::value) Local = 0, LocalArray[5] = {};
// CHECK-NEXT: DeclStmt
// CHECK-NEXT: VarDecl
// CHECK-NEXT: IntegerLiteral
// CHECK-NEXT: VarDecl
// CHECK-NEXT: InitListExpr
#pragma acc update self(Local, LocalArray, LocalArray[0], LocalArray[0:1])
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 'Local' 'decltype(T::value)'
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
// CHECK-NEXT: ArraySubscriptExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 1
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
#pragma acc update host(Local, LocalArray, LocalArray[0], LocalArray[0:1]) device(Local, LocalArray, LocalArray[0], LocalArray[0:1])
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
// CHECK-NEXT: host clause
// CHECK-NEXT: DeclRefExpr{{.*}} 'Local' 'decltype(T::value)'
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
// CHECK-NEXT: ArraySubscriptExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 1
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: device clause
// CHECK-NEXT: DeclRefExpr{{.*}} 'Local' 'decltype(T::value)'
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
// CHECK-NEXT: ArraySubscriptExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(T::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 1
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
// Instantiation:
// CHECK-NEXT: FunctionDecl{{.*}} TemplFunc 'void (SomeStruct)' implicit_instantiation
// CHECK-NEXT: TemplateArgument type 'SomeStruct'
// CHECK-NEXT: RecordType{{.*}} 'SomeStruct'
// CHECK-NEXT: CXXRecord{{.*}} 'SomeStruct'
// CHECK-NEXT: ParmVarDecl{{.*}} t 'SomeStruct'
// CHECK-NEXT: CompoundStmt
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'SomeStruct'
[OpenACC] Enable 'if' and 'if_present' for 'update' construct The only restriction on 'if' is that only 1 can appear on an update construct, so this enforces that. 'if_present' has no restrictions.
2025-01-07 08:19:31 -08:00
// CHECK-NEXT: if_present clause
// CHECK-NEXT: if clause
// CHECK-NEXT: BinaryOperator{{.*}}'bool' '<'
// CHECK-NEXT: ImplicitCastExpr {{.*}}'unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}}'value' 'const unsigned int'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'SomeStruct'
// CHECK-NEXT: ImplicitCastExpr {{.*}}'unsigned int'
// CHECK-NEXT: CXXMemberCallExpr{{.*}}'unsigned int'
// CHECK-NEXT: MemberExpr{{.*}}.operator unsigned int
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: DeclRefExpr{{.*}}'t' 'SomeStruct'
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'SomeStruct'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: async clause
[OpenACC] Start enforcing 'device_type' clause values Researching in prep of doing the implementation for lowering, I found that the source of the valid identifiers list from flang is in the frontend. This patch adds the same list to the frontend, but does it as a sema diagnostic, so we still parse it as an identifier/identifier-like thing, but then diagnose it as invalid later.
2025-04-09 14:20:15 -07:00
// CHECK-NEXT: device_type(default)
// CHECK-NEXT: dtype(host)
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'SomeStruct'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}}'value' 'const unsigned int'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'SomeStruct'
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: CXXMemberCallExpr{{.*}}'unsigned int'
// CHECK-NEXT: MemberExpr{{.*}}.operator unsigned int
// CHECK-NEXT: DeclRefExpr{{.*}}'t' 'SomeStruct'
// CHECK-NEXT: async clause
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}}'value' 'const unsigned int'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'SomeStruct'
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'SomeStruct'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: <<<NULL>>>
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}}'value' 'const unsigned int'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'SomeStruct'
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: CXXMemberCallExpr{{.*}}'unsigned int'
// CHECK-NEXT: MemberExpr{{.*}}.operator unsigned int
// CHECK-NEXT: DeclRefExpr{{.*}}'t' 'SomeStruct'
// CHECK-NEXT: async clause
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: CXXMemberCallExpr{{.*}}'unsigned int'
// CHECK-NEXT: MemberExpr{{.*}}.operator unsigned int
// CHECK-NEXT: DeclRefExpr{{.*}}'t' 'SomeStruct'
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 't' 'SomeStruct'
[OpenACC] enable 'async' and 'wait' for 'update' construct These work the same here as they do for every other construct, so this is as simple as enabling them and writing tests, which this patch does.
2025-01-07 10:02:35 -08:00
// CHECK-NEXT: wait clause
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}}'value' 'const unsigned int'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'SomeStruct'
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: CXXMemberCallExpr{{.*}}'unsigned int'
// CHECK-NEXT: MemberExpr{{.*}}.operator unsigned int
// CHECK-NEXT: DeclRefExpr{{.*}}'t' 'SomeStruct'
// CHECK-NEXT: ImplicitCastExpr{{.*}}'unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}}'value' 'const unsigned int'
// CHECK-NEXT: NestedNameSpecifier TypeSpec 'SomeStruct'
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
// CHECK-NEXT: DeclStmt
// CHECK-NEXT: VarDecl
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: IntegerLiteral
// CHECK-NEXT: VarDecl
// CHECK-NEXT: InitListExpr
// CHECK-NEXT: array_filler
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
// CHECK-NEXT: self clause
// CHECK-NEXT: DeclRefExpr{{.*}} 'Local' 'decltype(SomeStruct::value)':'const unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
// CHECK-NEXT: ArraySubscriptExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
[OpenACC] Enable 'self' sema for 'update' construct The 'self' clause is an unfortunately difficult one, as it has a significantly different meaning between 'update' and the other constructs. This patch introduces a way for the 'self' clause to work as both. I considered making this two separate AST nodes (one for 'self' on 'update' and one for the others), however this makes the automated macros/etc for supporting a clause break. Instead, 'self' has the ability to act as either a condition or as a var-list clause. As this is the only one of its kind, it is implemented all within it. If in the future we have more that work like this, we should consider rewriting a lot of the macros that we use to make clauses work, and make them separate ast nodes.
2025-01-08 10:42:40 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 1
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: OpenACCUpdateConstruct{{.*}}update
// CHECK-NEXT: host clause
// CHECK-NEXT: DeclRefExpr{{.*}} 'Local' 'decltype(SomeStruct::value)':'const unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
// CHECK-NEXT: ArraySubscriptExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 1
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: device clause
// CHECK-NEXT: DeclRefExpr{{.*}} 'Local' 'decltype(SomeStruct::value)':'const unsigned int'
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
// CHECK-NEXT: ArraySubscriptExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
// CHECK-NEXT: ArraySectionExpr
// CHECK-NEXT: ImplicitCastExpr
// CHECK-NEXT: DeclRefExpr{{.*}} 'LocalArray' 'decltype(SomeStruct::value)[5]'
[OpenACC] Implement 'at least one of' restriction for 'update' This completes the implementation of 'update' by implementing its last restriction. This restriction requires at least 1 of the 'self', 'host', or 'device' clauses.
2025-01-09 08:59:31 -08:00
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 0
// CHECK-NEXT: IntegerLiteral{{.*}}'int' 1
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
}
struct SomeStruct{
static constexpr unsigned value = 5;
operator unsigned();
};
void use() {
TemplFunc(SomeStruct{});
}
#endif
Reference in New Issue Copy Permalink