Provided by: opencl-1.2-man-doc_1.0~svn22836-1.1_all bug


       Attributes_of_Variables - Attributes of Variables.

       __attribute__ ((aligned)) __attribute__
       ((aligned (n))) __attribute__ ((packed))
       __attribute__ ((endian(host))) __attribute__


       The keyword __attribute__ allows you to specify special attributes of variables or
       structure fields. This keyword is followed by an attribute specification inside double
       parentheses. The aligned, packed, and endian attribute qualifiers are defined below.

   aligned (alignment)
       This attribute specifies a minimum alignment for the variable or structure field, measured
       in bytes. For example, the declaration:

       int x __attribute__ ((aligned (16))) = 0;

       causes the compiler to allocate the global variable x on a 16-byte boundary. The alignment
       value specified must be a power of two.

       You can also specify the alignment of structure fields. For example, to create double-word
       aligned int pair, you could write:

       struct foo { int x[2] __attribute__ ((aligned
       (8))); };

       This is an alternative to creating a union with a double member that forces the union to
       be double-word aligned.

       As in the preceding examples, you can explicitly specify the alignment (in bytes) that you
       wish the compiler to use for a given variable or structure field. Alternatively, you can
       leave out the alignment factor and just ask the compiler to align a variable or field to
       the maximum useful alignment for the target machine you are compiling for. For example,
       you could write:

       short array[3] __attribute__ ((aligned));

       Whenever you leave out the alignment factor in an aligned attribute specification, the
       OpenCL compiler automatically sets the alignment for the declared variable or field to the
       largest alignment which is ever used for any data type on the target device you are
       compiling for.

       When used on a struct, or struct member, the aligned attribute can only increase the
       alignment; in order to decrease it, the packed attribute must be specified as well. When
       used as part of a typedef, the aligned attribute can both increase and decrease alignment,
       and specifying the packed attribute will generate a warning.

       Note that the effectiveness of aligned attributes may be limited by inherent limitations
       of the OpenCL device and compiler. For some devices, the OpenCL compiler may only be able
       to arrange for variables to be aligned up to a certain maximum alignment. If the OpenCL
       compiler is only able to align variables up to a maximum of 8 byte alignment, then
       specifying aligned(16) in an __attribute__ will still only provide you with 8 byte
       alignment. See your platform-specific documentation for further information.

       The packed attribute specifies that a variable or structure field should have the smallest
       possible alignment -- one byte for a variable, unless you specify a larger value with the
       aligned attribute.

       Here is a structure in which the field x is packed, so that it immediately follows a:

       struct foo { char a; int x[2] __attribute__
       ((packed)); };

       An attribute list placed at the beginning of a user-defined type applies to the variable
       of that type and not the type, while attributes following the type body apply to the type.

       For example:

       /* a has alignment of 128 */
       __attribute__((aligned(128))) struct A {int i;}

       /* b has alignment of 16 */
       __attribute__((aligned(16))) struct B {double
       d;} __attribute__((aligned(32))) b ;

       struct A a1; /* a1 has alignment of 4 */

       struct B b1; /* b1 has alignment of 32 */

   endian (endiantype)
       The endian attribute determines the byte ordering of a variable.  endiantype can be set to
       host indicating the variable uses the endianness of the host processor or can be set to
       device indicating the variable uses the endianness of the device on which the kernel will
       be executed. The default is device. For example:

       float4 *p   __attribute__ ((endian(host)));

       specifies that data stored in memory pointed to by p will be in the host endian format.


       OpenCL Specification[1]


       attribute(3clc), attributes-blocksAndControlFlow(3clc), attributes-types(3clc)


       The Khronos Group


       Copyright © 2007-2011 The Khronos Group Inc.
       Permission is hereby granted, free of charge, to any person obtaining a copy of this
       software and/or associated documentation files (the "Materials"), to deal in the Materials
       without restriction, including without limitation the rights to use, copy, modify, merge,
       publish, distribute, sublicense, and/or sell copies of the Materials, and to permit
       persons to whom the Materials are furnished to do so, subject to the condition that this
       copyright notice and permission notice shall be included in all copies or substantial
       portions of the Materials.


        1. OpenCL Specification
           page 239, section 6.11.3 - Specifying Attributes of Variables