clang: clang::ArraySectionExpr Class Reference (original) (raw)
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differentiator. More...
Public Types
enum
ArraySectionType { OMPArraySection, OpenACCArraySection }
Public Types inherited from clang::Expr
enum
LValueClassification {
LV_Valid, LV_NotObjectType, LV_IncompleteVoidType, LV_DuplicateVectorComponents,
LV_InvalidExpression, LV_InvalidMessageExpression, LV_MemberFunction, LV_SubObjCPropertySetting,
LV_ClassTemporary, LV_ArrayTemporary
}
enum
isModifiableLvalueResult {
MLV_Valid, MLV_NotObjectType, MLV_IncompleteVoidType, MLV_DuplicateVectorComponents,
MLV_InvalidExpression, MLV_LValueCast, MLV_IncompleteType, MLV_ConstQualified,
MLV_ConstQualifiedField, MLV_ConstAddrSpace, MLV_ArrayType, MLV_NoSetterProperty,
MLV_MemberFunction, MLV_SubObjCPropertySetting, MLV_InvalidMessageExpression, MLV_ClassTemporary,
MLV_ArrayTemporary
}
enum
SideEffectsKind { SE_NoSideEffects, SE_AllowUndefinedBehavior, SE_AllowSideEffects }
enum class
ConstantExprKind { Normal, NonClassTemplateArgument, ClassTemplateArgument, ImmediateInvocation }
enum
NullPointerConstantKind {
NPCK_NotNull = 0 , NPCK_ZeroExpression, NPCK_ZeroLiteral, NPCK_CXX11_nullptr,
NPCK_GNUNull
}
Enumeration used to describe the kind of Null pointer constant returned from [isNullPointerConstant()](classclang%5F1%5F1Expr.html#aa1d79a39abcf576a82b97cff17f893f8 "isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant."). More...
enum
NullPointerConstantValueDependence { NPC_NeverValueDependent = 0 , NPC_ValueDependentIsNull, NPC_ValueDependentIsNotNull }
Enumeration used to describe how [isNullPointerConstant()](classclang%5F1%5F1Expr.html#aa1d79a39abcf576a82b97cff17f893f8 "isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.") should cope with value-dependent expressions. More...
Public Types inherited from clang::Stmt
enum
StmtClass { NoStmtClass = 0 }
enum
Likelihood { LH_Unlikely = -1 , LH_None, LH_Likely }
The likelihood of a branch being taken. More...
using
Child Iterators: All subclasses must implement 'children' to permit easy iteration over the substatements/subexpressions of an AST node.
using
const_child_iterator = ConstStmtIterator
using
child_range = llvm::iterator_range< child_iterator >
using
const_child_range = llvm::iterator_range< const_child_iterator >
Public Member Functions
ArraySectionExpr (Expr *Base, Expr *LowerBound, Expr *Length, Expr *Stride, QualType Type, ExprValueKind VK, ExprObjectKind OK, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, SourceLocation RBracketLoc)
ArraySectionExpr (Expr *Base, Expr *LowerBound, Expr *Length, QualType Type, ExprValueKind VK, ExprObjectKind OK, SourceLocation ColonLoc, SourceLocation RBracketLoc)
ArraySectionExpr (EmptyShell Shell)
Create an empty array section expression.
isOMPArraySection () const
isOpenACCArraySection () const
Expr *
getBase ()
Get base of the array section.
const Expr *
getBase () const
Expr *
Get lower bound of array section.
const Expr *
getLowerBound () const
Expr *
getLength ()
Get length of array section.
const Expr *
getLength () const
Expr *
getStride ()
Get stride of array section.
const Expr *
getStride () const
getBeginLoc () const LLVM_READONLY
getEndLoc () const LLVM_READONLY
getColonLocFirst () const
getColonLocSecond () const
getRBracketLoc () const
getExprLoc () const LLVM_READONLY
children ()
children () const
Public Member Functions inherited from clang::Expr
Expr ()=delete
Expr &
operator= (const Expr &)=delete
Expr &
getType () const
void
getEnumCoercedType (const ASTContext &Ctx) const
If this expression is an enumeration constant, return the enumeration type under which said constant was declared.
getDependence () const
isValueDependent () const
Determines whether the value of this expression depends on.
isTypeDependent () const
Determines whether the type of this expression depends on.
isInstantiationDependent () const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
containsUnexpandedParameterPack () const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
containsErrors () const
Whether this expression contains subexpressions which had errors, e.g.
getExprLoc () const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic expression.
isReadIfDiscardedInCPlusPlus11 () const
Determine whether an lvalue-to-rvalue conversion should implicitly be applied to this expression if it appears as a discarded-value expression in C++11 onwards.
isUnusedResultAWarning (const Expr *&WarnExpr, SourceLocation &Loc, SourceRange &R1, SourceRange &R2, ASTContext &Ctx) const
isUnusedResultAWarning - Return true if this immediate expression should be warned about if the result is unused.
isLValue () const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
isPRValue () const
isXValue () const
isGLValue () const
ClassifyLValue (ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
isModifiableLvalue (ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplete type, does not have a const-qualified type, and if it is a structure or union, does not have any member (including, recursively, any member or element of all contained aggregates or unions) with a const-qualified type.
Classify (ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
ClassifyModifiable (ASTContext &Ctx, SourceLocation &Loc) const
ClassifyModifiable - Classify this expression according to the C++11 expression taxonomy, and see if it is valid on the left side of an assignment.
getFPFeaturesInEffect (const LangOptions &LO) const
Returns the set of floating point options that apply to this expression.
getValueKind () const
getValueKind - The value kind that this expression produces.
getObjectKind () const
getObjectKind - The object kind that this expression produces.
isOrdinaryOrBitFieldObject () const
void
setValueKind (ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
void
setObjectKind (ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
refersToBitField () const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
If this expression refers to an enum constant, retrieve its declaration.
const EnumConstantDecl *
getEnumConstantDecl () const
const FieldDecl *
getSourceBitField () const
Decl *
const Decl *
getReferencedDeclOfCallee () const
const ObjCPropertyRefExpr *
getObjCProperty () const
If this expression is an l-value for an Objective C property, find the underlying property reference expression.
isObjCSelfExpr () const
Check if this expression is the ObjC 'self' implicit parameter.
refersToVectorElement () const
Returns whether this expression refers to a vector element.
refersToMatrixElement () const
Returns whether this expression refers to a matrix element.
refersToGlobalRegisterVar () const
Returns whether this expression refers to a global register variable.
hasPlaceholderType () const
Returns whether this expression has a placeholder type.
hasPlaceholderType (BuiltinType::Kind K) const
Returns whether this expression has a specific placeholder type.
isKnownToHaveBooleanValue (bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or 1.
isFlexibleArrayMemberLike (ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const
Check whether this array fits the idiom of a flexible array member, depending on the value of -fstrict-flex-array.
std::optional< llvm::APSInt >
getIntegerConstantExpr (const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
isIntegerConstantExpr (const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isCXX98IntegralConstantExpr (const ASTContext &Ctx) const
isCXX98IntegralConstantExpr - Return true if this expression is an integral constant expression in C++98.
isCXX11ConstantExpr (const ASTContext &Ctx, APValue *Result=nullptr, SourceLocation *Loc=nullptr) const
isCXX11ConstantExpr - Return true if this expression is a constant expression in C++11.
isConstantInitializer (ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant, and thus can be used as a constant initializer in C.
const ValueDecl *
getAsBuiltinConstantDeclRef (const ASTContext &Context) const
If this expression is an unambiguous reference to a single declaration, in the style of __builtin_function_start, return that declaration.
EvaluateAsRValue (EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy technique (that has nothing to do with language standards) that we want to, even if the expression has side-effects.
EvaluateAsBooleanCondition (bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boolean condition using any crazy technique that we want to, even if the expression has side-effects.
EvaluateAsInt (EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer, using any crazy technique that we want to.
EvaluateAsFloat (llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point value, using any crazy technique that we want to.
EvaluateAsFixedPoint (EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFixedPoint - Return true if this is a constant which we can fold and convert to a fixed point value.
isEvaluatable (const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-effects, but discard the result.
HasSideEffects (const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than producing a value.
hasNonTrivialCall (const ASTContext &Ctx) const
Determine whether this expression involves a call to any function that is not trivial.
llvm::APSInt
EvaluateKnownConstInt (const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
llvm::APSInt
EvaluateKnownConstIntCheckOverflow (const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
void
EvaluateForOverflow (const ASTContext &Ctx) const
EvaluateAsLValue (EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known address, with no side-effects.
EvaluateAsInitializer (APValue &Result, const ASTContext &Ctx, const VarDecl *VD, SmallVectorImpl< PartialDiagnosticAt > &Notes, bool IsConstantInitializer) const
EvaluateAsInitializer - Evaluate an expression as if it were the initializer of the given declaration.
EvaluateWithSubstitution (APValue &Value, ASTContext &Ctx, const FunctionDecl *Callee, ArrayRef< const Expr * > Args, const Expr *This=nullptr) const
EvaluateWithSubstitution - Evaluate an expression as if from the context of a call to the given function with the given arguments, inside an unevaluated context.
EvaluateAsConstantExpr (EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
tryEvaluateObjectSize (uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available where the pointer is pointing.
tryEvaluateStrLen (uint64_t &Result, ASTContext &Ctx) const
If the current Expr is a pointer, this will try to statically determine the strlen of the string pointed to.
EvaluateCharRangeAsString (std::string &Result, const Expr *SizeExpression, const Expr *PtrExpression, ASTContext &Ctx, EvalResult &Status) const
std::optional< std::string >
tryEvaluateString (ASTContext &Ctx) const
If the current Expr can be evaluated to a pointer to a null-terminated constant string, return the constant string (without the terminating null).
isNullPointerConstant (ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
isOBJCGCCandidate (ASTContext &Ctx) const
isOBJCGCCandidate - Return true if this expression may be used in a read/ write barrier.
isBoundMemberFunction (ASTContext &Ctx) const
Returns true if this expression is a bound member function.
Expr *
IgnoreUnlessSpelledInSource ()
Skip past any invisible AST nodes which might surround this statement, such as ExprWithCleanups or ImplicitCastExpr nodes, but also injected CXXMemberExpr and CXXConstructExpr which represent implicit conversions.
const Expr *
IgnoreUnlessSpelledInSource () const
Expr *
IgnoreImpCasts () LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
const Expr *
IgnoreImpCasts () const
Expr *
IgnoreCasts () LLVM_READONLY
Skip past any casts which might surround this expression until reaching a fixed point.
const Expr *
IgnoreCasts () const
Expr *
IgnoreImplicit () LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
const Expr *
IgnoreImplicit () const
Expr *
IgnoreImplicitAsWritten () LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
const Expr *
IgnoreImplicitAsWritten () const
Expr *
IgnoreParens () LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
const Expr *
IgnoreParens () const
Expr *
IgnoreParenImpCasts () LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fixed point.
const Expr *
IgnoreParenImpCasts () const
Expr *
IgnoreParenCasts () LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point.
const Expr *
IgnoreParenCasts () const
Expr *
IgnoreConversionOperatorSingleStep () LLVM_READONLY
Skip conversion operators.
const Expr *
IgnoreConversionOperatorSingleStep () const
Expr *
IgnoreParenLValueCasts () LLVM_READONLY
Skip past any parentheses and lvalue casts which might surround this expression until reaching a fixed point.
const Expr *
IgnoreParenLValueCasts () const
Expr *
IgnoreParenNoopCasts (const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the same size) until reaching a fixed point.
const Expr *
IgnoreParenNoopCasts (const ASTContext &Ctx) const
Expr *
IgnoreParenBaseCasts () LLVM_READONLY
Skip past any parentheses and derived-to-base casts until reaching a fixed point.
const Expr *
IgnoreParenBaseCasts () const
isDefaultArgument () const
Determine whether this expression is a default function argument.
isTemporaryObject (ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
isImplicitCXXThis () const
Whether this expression is an implicit reference to 'this' in C++.
const CXXRecordDecl *
getBestDynamicClassType () const
For an expression of class type or pointer to class type, return the most derived class decl the expression is known to refer to.
const Expr *
getBestDynamicClassTypeExpr () const
Get the inner expression that determines the best dynamic class.
const Expr *
skipRValueSubobjectAdjustments (SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetime needs to be extended.
const Expr *
skipRValueSubobjectAdjustments () const
Public Member Functions inherited from clang::ValueStmt
const Expr *
getExprStmt () const
Expr *
getExprStmt ()
Public Member Functions inherited from clang::Stmt
void *
operator new (size_t bytes, const ASTContext &C, unsigned alignment=8)
void *
operator new (size_t bytes, const ASTContext *C, unsigned alignment=8)
void *
operator new (size_t bytes, void *mem) noexcept
void
operator delete (void *, const ASTContext &, unsigned) noexcept
void
operator delete (void *, const ASTContext *, unsigned) noexcept
void
operator delete (void *, size_t) noexcept
void
operator delete (void *, void *) noexcept
Stmt ()=delete
Stmt &
operator= (const Stmt &)=delete
Stmt &
getStmtClass () const
const char *
getStmtClassName () const
getSourceRange () const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpreted by SourceManager.
getBeginLoc () const LLVM_READONLY
getEndLoc () const LLVM_READONLY
void
dump () const
Dumps the specified AST fragment and all subtrees to llvm::errs().
void
dump (raw_ostream &OS, const ASTContext &Context) const
int64_t
getID (const ASTContext &Context) const
void
dumpColor () const
dumpColor - same as dump(), but forces color highlighting.
void
dumpPretty (const ASTContext &Context) const
dumpPretty/printPretty - These two methods do a "pretty print" of the AST back to its original source language syntax.
void
printPretty (raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
void
printPrettyControlled (raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
void
printJson (raw_ostream &Out, PrinterHelper *Helper, const PrintingPolicy &Policy, bool AddQuotes) const
Pretty-prints in JSON format.
void
viewAST () const
viewAST - Visualize an AST rooted at this Stmt* using GraphViz.
Stmt *
IgnoreContainers (bool IgnoreCaptured=false)
Skip no-op (attributed, compound) container stmts and skip captured stmt at the top, if IgnoreCaptured is true.
const Stmt *
IgnoreContainers (bool IgnoreCaptured=false) const
const Stmt *
stripLabelLikeStatements () const
Strip off all label-like statements.
Stmt *
children ()
children () const
child_begin ()
child_end ()
child_begin () const
child_end () const
void
Profile (llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
void
ProcessODRHash (llvm::FoldingSetNodeID &ID, ODRHash &Hash) const
Calculate a unique representation for a statement that is stable across compiler invocations.
Static Public Member Functions
static QualType
getBaseOriginalType (const Expr *Base)
Return original type of the base expression for array section.
static bool
Static Public Member Functions inherited from clang::Expr
static ExprValueKind
getValueKindForType (QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
static bool
isPotentialConstantExpr (const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function's definition might be usable in a constant expression in C++11, if it were marked constexpr.
static bool
isPotentialConstantExprUnevaluated (Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluated - Return true if this expression might be usable in a constant expression in C++11 in an unevaluated context, if it were in function FD marked constexpr.
static QualType
findBoundMemberType (const Expr *expr)
Given an expression of bound-member type, find the type of the member.
static bool
hasAnyTypeDependentArguments (ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
static bool
isSameComparisonOperand (const Expr *E1, const Expr *E2)
Checks that the two Expr's will refer to the same value as a comparison operand.
static bool
Static Public Member Functions inherited from clang::ValueStmt
static bool
Static Public Member Functions inherited from clang::Stmt
static void
addStmtClass (const StmtClass s)
static void
static void
PrintStats ()
static Likelihood
getLikelihood (ArrayRef< const Attr * > Attrs)
static Likelihood
getLikelihood (const Stmt *S)
static const Attr *
getLikelihoodAttr (const Stmt *S)
static Likelihood
getLikelihood (const Stmt *Then, const Stmt *Else)
static std::tuple< bool, const Attr *, const Attr * >
determineLikelihoodConflict (const Stmt *Then, const Stmt *Else)
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differentiator.
OpenMP 5.0 [2.1.5, Array Sections]. To specify an array section in an OpenMP construct, array subscript expressions are extended with the following syntax:
[ lower-bound : length : stride ]
[ lower-bound : length : ]
[ lower-bound : : stride ]
[ lower-bound : : ]
[ lower-bound : ]
[ : : stride ]
[ : : ]
[ : ]
float __ovld __cnfn length(float)
Return the length of vector p, i.e., sqrt(p.x2 + p.y 2 + ...)
The array section must be a subset of the original array. Array sections are allowed on multidimensional arrays. Base language array subscript expressions can be used to specify length-one dimensions of multidimensional array sections. Each of the lower-bound, length, and stride expressions if specified must be an integral type expressions of the base language. When evaluated they represent a set of integer values as follows:
{ lower-bound, lower-bound + stride, lower-bound + 2 * stride,... ,
lower-bound + ((length - 1) * stride) }
The lower-bound and length must evaluate to non-negative integers. The stride must evaluate to a positive integer. When the size of the array dimension is not known, the length must be specified explicitly. When the stride is absent it defaults to 1. When the length is absent it defaults to ⌈(size − lower-bound)/stride⌉, where size is the size of the array dimension. When the lower-bound is absent it defaults to 0.
OpenACC 3.3 [2.7.1 Data Specification in Data Clauses] In C and C++, a subarray is an array name followed by an extended array range specification in brackets, with start and length, such as
AA[2:n]
If the lower bound is missing, zero is used. If the length is missing and the array has known size, the size of the array is used; otherwise the length is required. The subarray AA[2:n] means elements AA[2], AA[3], . . . , AA[2+n-1]. In C and C++, a two dimensional array may be declared in at least four ways:
-Statically-sized array: float AA[100][200]; -Pointer to statically sized rows: typedef float row[200]; row* BB; -Statically-sized array of pointers: float* CC[200]; -Pointer to pointers: float** DD;
Each dimension may be statically sized, or a pointer to dynamically allocated memory. Each of these may be included in a data clause using subarray notation to specify a rectangular array:
-AA[2:n][0:200] -BB[2:n][0:m] -CC[2:n][0:m] -DD[2:n][0:m]
Multidimensional rectangular subarrays in C and C++ may be specified for any array with any combination of statically-sized or dynamically-allocated dimensions. For statically sized dimensions, all dimensions except the first must specify the whole extent to preserve the contiguous data restriction, discussed below. For dynamically allocated dimensions, the implementation will allocate pointers in device memory corresponding to the pointers in local memory and will fill in those pointers as appropriate.
In Fortran, a subarray is an array name followed by a comma-separated list of range specifications in parentheses, with lower and upper bound subscripts, such as
arr(1:high,low:100)
If either the lower or upper bounds are missing, the declared or allocated bounds of the array, if known, are used. All dimensions except the last must specify the whole extent, to preserve the contiguous data restriction, discussed below.
Restrictions
-In Fortran, the upper bound for the last dimension of an assumed-size dummy array must be specified.
-In C and C++, the length for dynamically allocated dimensions of an array must be explicitly specified.
-In C and C++, modifying pointers in pointer arrays during the data lifetime, either on the host or on the device, may result in undefined behavior.
-If a subarray appears in a data clause, the implementation may choose to allocate memory for only that subarray on the accelerator.
-In Fortran, array pointers may appear, but pointer association is not preserved in device memory.
-Any array or subarray in a data clause, including Fortran array pointers, must be a contiguous section of memory, except for dynamic multidimensional C arrays.
-In C and C++, if a variable or array of composite type appears, all the data members of the struct or class are allocated and copied, as appropriate. If a composite member is a pointer type, the data addressed by that pointer are not implicitly copied.
-In Fortran, if a variable or array of composite type appears, all the members of that derived type are allocated and copied, as appropriate. If any member has the allocatable or pointer attribute, the data accessed through that member are not copied.
-If an expression is used in a subscript or subarray expression in a clause on a data construct, the same value is used when copying data at the end of the data region, even if the values of variables in the expression change during the data region.