A named data storage block, for which the value can be defined and redefined during the execution of a program.

COMMENT: An array element or structure element is a variable that is part of another variable.

For C/C++, a scalar variable, as defined by the base language.

For Fortran, a scalar variable with intrinsic type, as defined by the base language, excluding character type.

A variable, such as an array or structure, composed of other variables. For Fortran, a variable of character type is considered an aggregate variable.

A designated subset of the elements of an array that is specified using a subscript notation that can select more than one element.

An array, an array section, or an array element.

For C/C++, an array shaping operator that reinterprets a pointer expression as an array with one or more specified dimensions.

For C/C++, the set of array elements of non-array type T that may be accessed by applying a sequence of [] operators to a given pointer that is either a pointer to type T or a pointer to a multidimensional array of elements of type T.

For Fortran, the set of array elements for a given array pointer.

COMMENT: For C/C++, the implicit array for pointer p with type T (*)[10] consists of all accessible elements p[i][j], for all i and j=0,1,...,9.

For C/C++, an lvalue pointer expression that is used by a given lvalue expression or array section to refer indirectly to its storage, where the lvalue expression or array section is part of the implicit array for that lvalue pointer expression.

For Fortran, a data pointer that appears last in the designator for a given variable or array section, where the variable or array section is part of the pointer target for that data pointer.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the base pointer is: (*p0).x0[k1].p1->p2.

For C/C++, the base pointer of a given lvalue expression or array section, or the base pointer of one of its named pointers.

For Fortran, the base pointer of a given variable or array section, or the base pointer of one of its named pointers.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the named pointers are: p0, (*p0).x0[k1].p1, and (*p0).x0[k1].p1->p2.

For C/C++, a non-subscripted array (a containing array) to which a series of zero or more array subscript operators and/or . (dot) operators are applied to yield a given lvalue expression or array section for which storage is contained by the array.

For Fortran, an array (a containing array) without the POINTER attribute and without a subscript list to which a series of zero or more array subscript operators and/or component selectors are applied to yield a given variable or array section for which storage is contained by the array.

COMMENT: An array is a containing array of itself. For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the containing arrays are: (*p0).x0[k1].p1->p2[k2].x1 and (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

For C/C++, a structure to which a series of zero or more . (dot) operators and/or array subscript operators are applied to yield a given lvalue expression or array section for which storage is contained by the structure.

For Fortran, a structure to which a series of zero or more component selectors and/or array subscript selectors are applied to yield a given variable or array section for which storage is contained by the structure.

COMMENT: A structure is a containing structure of itself. For C/C++, a structure pointer p to which the -> operator applies is equivalent to the application of a . (dot) operator to (*p) for the purposes of determining containing structures.

For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the containing structures are: *(*p0).x0[k1].p1, (*(*p0).x0[k1].p1).p2[k2] and (*(*p0).x0[k1].p1).p2[k2].x1[k3]

For C/C++, a containing array of a given lvalue expression or array section that does not appear in the expression of any of its other containing arrays.

For Fortran, a containing array of a given variable or array section that does not appear in the designator of any of its other containing arrays.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the base array is: (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

For C/C++, a containing array of a given lvalue expression or array section, or a containing array of one of its named pointers.

For Fortran, a containing array of a given variable or array section, or a containing array of one of its named pointers.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the named arrays are: (*p0).x0, (*p0).x0[k1].p1->p2[k2].x1, and (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

The base array of a given array section or array element, if it exists; otherwise, the base pointer of the array section or array element.

COMMENT: For the array section (*p0).x0[k1].p1->p2[k2].x1[k3].x2[4][0:n], where identifiers pi have a pointer type declaration and identifiers xi have an array type declaration, the base expression is: (*p0).x0[k1].p1->p2[k2].x1[k3].x2.

More examples for C/C++:

• The base expression for x[i] and for x[i:n] is x, if x is an array or pointer.
• The base expression for x[5][i] and for x[5][i:n] is x, if x is a pointer to an array or x is 2-dimensional array.
• The base expression for y[5][i] and for y[5][i:n] is y[5], if y is an array of pointers or y is a pointer to a pointer.

Examples for Fortran:

• The base expression for x(i) and for x(i:j) is x.

For a given data entity that is a variable or array section, a variable denoted by a base language identifier that is either the data entity or is a containing array or containing structure of the data entity.

COMMENT:

Examples for C/C++:

• The data entities x, x[i], x[:n], x[i].y[j] and x[i].y[:n], where x and y have array type declarations, all have the base variable x.
• The lvalue expressions and array sections p[i], p[:n], p[i].y[j] and p[i].y[:n], where p has a pointer type and p[i].y has an array type, has a base pointer p but does not have a base variable.

Examples for Fortran:

• The data objects x, x(i), x(:n), x(i)%y(j) and x(i)%y(:n), where x and y have array type declarations, all have the base variable x.
• The data objects p(i), p(:n), p(i)%y(j) and p(i)%y(:n), where p has a pointer type and p(i)%y has an array type, has a base pointer p but does not have a base variable.
• For the associated pointer p, p is both its base variable and base pointer.

A pointer variable in a device data environment to which the effect of a map clause assigns the address of an object, minus some offset, that is created in the device data environment. The pointer is an attached pointer for the remainder of its lifetime in the device data environment.

An array section that statically can be determined to have contiguous storage or that, in Fortran, has the CONTIGUOUS attribute.

A structure is a variable that contains one or more variables.

For C/C++: Implemented using struct types.

For C++: Implemented using class types.

For Fortran: Implemented using derived types.

For C/C++, a string literal.

For Fortran, a character literal constant.

With respect to a given set of task regions or SIMD lanes that bind to the same parallel region, a variable for which the name provides access to a different block of storage for each task region or SIMD lane.

A variable that is part of another variable (as an array element or a structure element) cannot be made private independently of other components. If a variable is privatized, its components are also private.

With respect to a given set of task regions that bind to the same parallel region, a variable for which the name provides access to the same block of storage for each task region.

A variable that is part of another variable (as an array element or a structure element) cannot be shared independently of the other components, except for static data members of C++ classes.

A variable that is replicated, one instance per thread, by the OpenMP implementation. Its name then provides access to a different block of storage for each thread.

A variable that is part of another variable (as an array element or a structure element) cannot be made threadprivate independently of the other components, except for static data members of C++ classes. If a variable is made threadprivate, its components are also threadprivate.

The set of threadprivate variables associated with each thread.

The variables associated with the execution of a given region.

The initial data environment associated with a device.

An address of an object that may be referenced on a target device.

An implementation-defined handle that refers to a device address.

An original variable in a data environment with a corresponding variable in a device data environment.

COMMENT: The original and corresponding variables may share storage.

An operation that establishes or removes a correspondence between a variable in one data environment and another variable in a device data environment.

An operation that defines how variables of given type are to be mapped or updated with respect to a device data environment.

A mapper that is defined by a declare mapper directive.

The process that determines the final map types of the map operations that result from mapping a variable with a user-defined mapper.

A type that is valid for a mapped variable. If a type is composed from other types (such as the type of an array element or a structure element) and any of the other types are not mappable then the type is not mappable.

COMMENT: Pointer types are mappable but the memory block to which the pointer refers is not mapped.

For C, the type must be a complete type.

For C++, the type must be a complete type.

In addition, for class types:

• All member functions accessed in any target region must appear in a declare target directive.

For Fortran, no restrictions on the type except that for derived types:

• All type-bound procedures accessed in any target region must appear in a declare target directive.

For variables, the property of having a valid value.

For C, for the contents of variables, the property of having a valid value.

For C++, for the contents of variables of POD (plain old data) type, the property of having a valid value.

For variables of non-POD class type, the property of having been constructed but not subsequently destructed.

For Fortran, for the contents of variables, the property of having a valid value. For the allocation or association status of variables, the property of having a valid status.

COMMENT: Programs that rely upon variables that are not defined are non-conforming programs.

For C++, variables declared with one of the class, struct, or union keywords.

For C/C++, the lifetime of an object with static storage duration, as defined by the base language.

For Fortran, the lifetime of a variable with a SAVE attribute, implicit or explicit, a common block object or a variable declared in a module.

A null pointer. For C, the value NULL. For C++, the value NULL or the value nullptr. For Fortran, the value C_NULL_PTR.

A value that is not NULL.

A pointer that is not NULL.