[OpenACC] Implement `loop` restrictions on `for` loops. (#115370)

OpenACC restricts the contents of a 'for' loop affected by a 'loop'
construct without a 'seq'. The loop variable must be integer, p

[OpenACC] Implement `loop` restrictions on `for` loops. (#115370)

OpenACC restricts the contents of a 'for' loop affected by a 'loop'
construct without a 'seq'. The loop variable must be integer, pointer,
or random-access-iterator, it must monotonically increase/decrease, and
the trip count must be computable at runtime before the function.

This patch tries to implement some of these limitations to the best of
our ability, though it causes us to be perhaps overly restrictive at the
moment. I expect we'll revisit some of these rules/add additional
supported forms of loop-variable and 'monotonically increasing' here,
but the currently enforced rules are heavily inspired by the OMP
implementation here.

show more ...

[OpenACC] Implement 'reduction' Sema on 'loop' construct

The reduction clause has some minor restrictions on the variable
references that are implementable, so this implements those. Others
require

[OpenACC] Implement 'reduction' Sema on 'loop' construct

The reduction clause has some minor restrictions on the variable
references that are implementable, so this implements those. Others
require reachability analysis, so this patch documents that we're not
going to do that in the CFE(or at least save it for the MLIR passes).

show more ...

[OpenACC] Implement 'loop' 'vector' clause (#112259)

The 'vector' clause specifies the iterations to be executed in vector or
SIMD mode. There are some limitations on which associated compute
cont

[OpenACC] Implement 'loop' 'vector' clause (#112259)

The 'vector' clause specifies the iterations to be executed in vector or
SIMD mode. There are some limitations on which associated compute
contexts may be associated with this and have arguments, but otherwise
this is a fairly unrestricted clause.

It DOES have region limits like 'gang' and 'worker'.

show more ...

[OpenACC] implement loop 'worker' clause. (#112206)

The worker clause specifies iterations of the loop/ that are executed in
parallel by distributing the iterations among the multiple works within

[OpenACC] implement loop 'worker' clause. (#112206)

The worker clause specifies iterations of the loop/ that are executed in
parallel by distributing the iterations among the multiple works within
a single gang.

The sema rules for this type are simply that it cannot be combined with
a `kernel` construct with a `num_workers` clause, child `loop` clauses
cannot contain a `gang` or `worker` clause, and that the argument is oly
allowed when associated with a `kernel`.

show more ...

[OpenACC] Implement loop 'gang' clause. (#112006)

The 'gang' clause is used to specify parallel execution of loops, thus
has some complicated rules depending on the 'loop's associated compute
cons

[OpenACC] Implement loop 'gang' clause. (#112006)

The 'gang' clause is used to specify parallel execution of loops, thus
has some complicated rules depending on the 'loop's associated compute
construct. This patch implements all of those.

show more ...

[OpenACC] Implement 'tile' attribute AST (#110999)

The 'tile' clause shares quite a bit of the rules with 'collapse', so a
followup patch will add those tests/behaviors. This patch deals with
addi

[OpenACC] Implement 'tile' attribute AST (#110999)

The 'tile' clause shares quite a bit of the rules with 'collapse', so a
followup patch will add those tests/behaviors. This patch deals with
adding the AST node.

The 'tile' clause takes a series of integer constant expressions, or *.
The asterisk is now represented by a new OpenACCAsteriskSizeExpr node,
else this clause is very similar to others.

show more ...

[OpenACC] Add 'collapse' clause AST/basic Sema implementation (#109461)

The 'collapse' clause on a 'loop' construct is used to specify how many
nested loops are associated with the 'loop' construct

[OpenACC] Add 'collapse' clause AST/basic Sema implementation (#109461)

The 'collapse' clause on a 'loop' construct is used to specify how many
nested loops are associated with the 'loop' construct. It takes an
optional 'force' tag, and an integer constant expression as arguments.

There are many other restrictions based on the contents of the loop/etc,
but those are implemented in followup patches, for now, this patch just
adds the AST node and does basic argument checking on the loop-count.

show more ...

[OpenACC] Implement 'private' clause sema for loop constructs

This clause works identically as far as Sema is concerned, to the
'private' clause on compute constructs, so this simply adds tests and

[OpenACC] Implement 'private' clause sema for loop constructs

This clause works identically as far as Sema is concerned, to the
'private' clause on compute constructs, so this simply adds tests and
unblocks the ASTNode generation and Sema checking when used on loop
clauses.

show more ...

[OpenACC] Implement auto/seq/independent clause Sema for 'loop'

These three clauses are all quite trivial, as they take no parameters.
They are mutually exclusive, and 'seq' has some other exclusive

[OpenACC] Implement auto/seq/independent clause Sema for 'loop'

These three clauses are all quite trivial, as they take no parameters.
They are mutually exclusive, and 'seq' has some other exclusives that
are implemented here.

The ONE thing that isn't implemented is 2.9's restriction (line 2010):
'A loop associated with a 'loop' construct that does not have a 'seq'
clause must be written to meet all the following conditions'.

Future clauses will require similar work, so it'll be done as a
followup.

show more ...

[OpenACC] Implement 'device_type' sema for 'loop' construct

This clause is effectively identical to how this works on compute
clauses, however the list of clauses allowed after it are slightly
diffe

[OpenACC] Implement 'device_type' sema for 'loop' construct

This clause is effectively identical to how this works on compute
clauses, however the list of clauses allowed after it are slightly
different. This enables the clause for the 'loop', and ensures we're
permitting the correct list.

show more ...

[OpenACC] Loop construct basic Sema and AST work (#93742)

This patch implements the 'loop' construct AST, as well as the basic
appertainment rule. Additionally, it sets up the 'parent' compute
con

[OpenACC] Loop construct basic Sema and AST work (#93742)

This patch implements the 'loop' construct AST, as well as the basic
appertainment rule. Additionally, it sets up the 'parent' compute
construct, which is necessary for codegen/other diagnostics.

A 'loop' can apply to a for or range-for loop, otherwise it has no other
restrictions (though some of its clauses do).

show more ...