opencl-c-base.h File Reference (original) (raw)

Go to the source code of this file.

Macros
#define	__opencl_c_named_address_space_builtins 1

#define	__half half

#define	MAXFLOAT 0x1.fffffep127f
	Value of maximum non-infinite single-precision floating-point number.

#define	HUGE_VALF (__builtin_huge_valf())
	A positive float constant expression.

#define	HUGE_VAL (__builtin_huge_val())
	A positive double constant expression.

#define	INFINITY (__builtin_inff())
	A constant expression of type float representing positive or unsigned infinity.

#define	NAN as_float(INT_MAX)
	A constant expression of type float representing a quiet NaN.

#define	FP_ILOGB0 INT_MIN

#define	FP_ILOGBNAN INT_MAX

#define	FLT_DIG 6

#define	FLT_MANT_DIG 24

#define	FLT_MAX_10_EXP +38

#define	FLT_MAX_EXP +128

#define	FLT_MIN_10_EXP -37

#define	FLT_MIN_EXP -125

#define	FLT_RADIX 2

#define	FLT_MAX 0x1.fffffep127f

#define	FLT_MIN 0x1.0p-126f

#define	FLT_EPSILON 0x1.0p-23f

#define	M_E_F 2.71828182845904523536028747135266250f

#define	M_LOG2E_F 1.44269504088896340735992468100189214f

#define	M_LOG10E_F 0.434294481903251827651128918916605082f

#define	M_LN2_F 0.693147180559945309417232121458176568f

#define	M_LN10_F 2.30258509299404568401799145468436421f

#define	M_PI_F 3.14159265358979323846264338327950288f

#define	M_PI_2_F 1.57079632679489661923132169163975144f

#define	M_PI_4_F 0.785398163397448309615660845819875721f

#define	M_1_PI_F 0.318309886183790671537767526745028724f

#define	M_2_PI_F 0.636619772367581343075535053490057448f

#define	M_2_SQRTPI_F 1.12837916709551257389615890312154517f

#define	M_SQRT2_F 1.41421356237309504880168872420969808f

#define	M_SQRT1_2_F 0.707106781186547524400844362104849039f

#define	DBL_DIG 15

#define	DBL_MANT_DIG 53

#define	DBL_MAX_10_EXP +308

#define	DBL_MAX_EXP +1024

#define	DBL_MIN_10_EXP -307

#define	DBL_MIN_EXP -1021

#define	DBL_RADIX 2

#define	DBL_MAX 0x1.fffffffffffffp1023

#define	DBL_MIN 0x1.0p-1022

#define	DBL_EPSILON 0x1.0p-52

#define	M_E 0x1.5bf0a8b145769p+1

#define	M_LOG2E 0x1.71547652b82fep+0

#define	M_LOG10E 0x1.bcb7b1526e50ep-2

#define	M_LN2 0x1.62e42fefa39efp-1

#define	M_LN10 0x1.26bb1bbb55516p+1

#define	M_PI 0x1.921fb54442d18p+1

#define	M_PI_2 0x1.921fb54442d18p+0

#define	M_PI_4 0x1.921fb54442d18p-1

#define	M_1_PI 0x1.45f306dc9c883p-2

#define	M_2_PI 0x1.45f306dc9c883p-1

#define	M_2_SQRTPI 0x1.20dd750429b6dp+0

#define	M_SQRT2 0x1.6a09e667f3bcdp+0

#define	M_SQRT1_2 0x1.6a09e667f3bcdp-1

#define	CHAR_BIT 8

#define	SCHAR_MAX 127

#define	SCHAR_MIN (-128)

#define	UCHAR_MAX 255

#define	CHAR_MAX SCHAR_MAX

#define	CHAR_MIN SCHAR_MIN

#define	USHRT_MAX 65535

#define	SHRT_MAX 32767

#define	SHRT_MIN (-32768)

#define	UINT_MAX 0xffffffff

#define	INT_MAX 2147483647

#define	INT_MIN (-2147483647-1)

#define	ULONG_MAX 0xffffffffffffffffUL

#define	LONG_MAX 0x7fffffffffffffffL

#define	LONG_MIN (-0x7fffffffffffffffL-1)

#define	CLK_LOCAL_MEM_FENCE 0x01
	Queue a memory fence to ensure correct ordering of memory operations to local memory.

#define	CLK_GLOBAL_MEM_FENCE 0x02
	Queue a memory fence to ensure correct ordering of memory operations to global memory.

#define	CLK_IMAGE_MEM_FENCE 0x04
	Queue a memory fence to ensure correct ordering of memory operations between work-items of a work-group to image memory.

#define	ATOMIC_VAR_INIT(x) (x)

#define	ATOMIC_FLAG_INIT 0

#define	CLK_ADDRESS_NONE 0

#define	CLK_ADDRESS_CLAMP_TO_EDGE 2

#define	CLK_ADDRESS_CLAMP 4

#define	CLK_ADDRESS_REPEAT 6

#define	CLK_ADDRESS_MIRRORED_REPEAT 8

#define	CLK_NORMALIZED_COORDS_FALSE 0

#define	CLK_NORMALIZED_COORDS_TRUE 1

#define	CLK_FILTER_NEAREST 0x10

#define	CLK_FILTER_LINEAR 0x20

#define	CLK_SNORM_INT8 0x10D0

#define	CLK_SNORM_INT16 0x10D1

#define	CLK_UNORM_INT8 0x10D2

#define	CLK_UNORM_INT16 0x10D3

#define	CLK_UNORM_SHORT_565 0x10D4

#define	CLK_UNORM_SHORT_555 0x10D5

#define	CLK_UNORM_INT_101010 0x10D6

#define	CLK_SIGNED_INT8 0x10D7

#define	CLK_SIGNED_INT16 0x10D8

#define	CLK_SIGNED_INT32 0x10D9

#define	CLK_UNSIGNED_INT8 0x10DA

#define	CLK_UNSIGNED_INT16 0x10DB

#define	CLK_UNSIGNED_INT32 0x10DC

#define	CLK_HALF_FLOAT 0x10DD

#define	CLK_FLOAT 0x10DE

#define	CLK_UNORM_INT24 0x10DF

#define	CLK_UNORM_INT_101010_2 0x10E0

#define	CLK_R 0x10B0

#define	CLK_A 0x10B1

#define	CLK_RG 0x10B2

#define	CLK_RA 0x10B3

#define	CLK_RGB 0x10B4

#define	CLK_RGBA 0x10B5

#define	CLK_BGRA 0x10B6

#define	CLK_ARGB 0x10B7

#define	CLK_INTENSITY 0x10B8

#define	CLK_LUMINANCE 0x10B9

#define	CLK_Rx 0x10BA

#define	CLK_RGx 0x10BB

#define	CLK_RGBx 0x10BC

#define	CLK_DEPTH 0x10BD

#define	CLK_DEPTH_STENCIL 0x10BE

#define	CLK_sRGB 0x10BF

#define	CLK_sRGBx 0x10C0

#define	CLK_sRGBA 0x10C1

#define	CLK_sBGRA 0x10C2

#define	CLK_ABGR 0x10C3

#define	CLK_NULL_RESERVE_ID (__builtin_astype(((void*)(__SIZE_MAX__)), reserve_id_t))

#define	CL_COMPLETE 0x0

#define	CL_RUNNING 0x1

#define	CL_SUBMITTED 0x2

#define	CL_QUEUED 0x3

#define	CLK_SUCCESS 0

#define	CLK_ENQUEUE_FAILURE -101

#define	CLK_INVALID_QUEUE -102

#define	CLK_INVALID_NDRANGE -160

#define	CLK_INVALID_EVENT_WAIT_LIST -57

#define	CLK_DEVICE_QUEUE_FULL -161

#define	CLK_INVALID_ARG_SIZE -51

#define	CLK_EVENT_ALLOCATION_FAILURE -100

#define	CLK_OUT_OF_RESOURCES -5

#define	CLK_NULL_QUEUE 0

#define	CLK_NULL_EVENT (__builtin_astype(((__SIZE_MAX__)), clk_event_t))

#define	CLK_ENQUEUE_FLAGS_NO_WAIT 0x0

#define	CLK_ENQUEUE_FLAGS_WAIT_KERNEL 0x1

#define	CLK_ENQUEUE_FLAGS_WAIT_WORK_GROUP 0x2

#define	CLK_PROFILING_COMMAND_EXEC_TIME 0x1

#define	MAX_WORK_DIM 3

#define	as_char(x) __builtin_astype((x), char)
	OpenCL v1.1/1.2/2.0 s6.2.4.2 - as_type operators Reinterprets a data type as another data type of the same size.

#define	as_char2(x) __builtin_astype((x), char2)

#define	as_char3(x) __builtin_astype((x), char3)

#define	as_char4(x) __builtin_astype((x), char4)

#define	as_char8(x) __builtin_astype((x), char8)

#define	as_char16(x) __builtin_astype((x), char16)

#define	as_uchar(x) __builtin_astype((x), uchar)

#define	as_uchar2(x) __builtin_astype((x), uchar2)

#define	as_uchar3(x) __builtin_astype((x), uchar3)

#define	as_uchar4(x) __builtin_astype((x), uchar4)

#define	as_uchar8(x) __builtin_astype((x), uchar8)

#define	as_uchar16(x) __builtin_astype((x), uchar16)

#define	as_short(x) __builtin_astype((x), short)

#define	as_short2(x) __builtin_astype((x), short2)

#define	as_short3(x) __builtin_astype((x), short3)

#define	as_short4(x) __builtin_astype((x), short4)

#define	as_short8(x) __builtin_astype((x), short8)

#define	as_short16(x) __builtin_astype((x), short16)

#define	as_ushort(x) __builtin_astype((x), ushort)

#define	as_ushort2(x) __builtin_astype((x), ushort2)

#define	as_ushort3(x) __builtin_astype((x), ushort3)

#define	as_ushort4(x) __builtin_astype((x), ushort4)

#define	as_ushort8(x) __builtin_astype((x), ushort8)

#define	as_ushort16(x) __builtin_astype((x), ushort16)

#define	as_int(x) __builtin_astype((x), int)

#define	as_int2(x) __builtin_astype((x), int2)

#define	as_int3(x) __builtin_astype((x), int3)

#define	as_int4(x) __builtin_astype((x), int4)

#define	as_int8(x) __builtin_astype((x), int8)

#define	as_int16(x) __builtin_astype((x), int16)

#define	as_uint(x) __builtin_astype((x), uint)

#define	as_uint2(x) __builtin_astype((x), uint2)

#define	as_uint3(x) __builtin_astype((x), uint3)

#define	as_uint4(x) __builtin_astype((x), uint4)

#define	as_uint8(x) __builtin_astype((x), uint8)

#define	as_uint16(x) __builtin_astype((x), uint16)

#define	as_long(x) __builtin_astype((x), long)

#define	as_long2(x) __builtin_astype((x), long2)

#define	as_long3(x) __builtin_astype((x), long3)

#define	as_long4(x) __builtin_astype((x), long4)

#define	as_long8(x) __builtin_astype((x), long8)

#define	as_long16(x) __builtin_astype((x), long16)

#define	as_ulong(x) __builtin_astype((x), ulong)

#define	as_ulong2(x) __builtin_astype((x), ulong2)

#define	as_ulong3(x) __builtin_astype((x), ulong3)

#define	as_ulong4(x) __builtin_astype((x), ulong4)

#define	as_ulong8(x) __builtin_astype((x), ulong8)

#define	as_ulong16(x) __builtin_astype((x), ulong16)

#define	as_float(x) __builtin_astype((x), float)

#define	as_float2(x) __builtin_astype((x), float2)

#define	as_float3(x) __builtin_astype((x), float3)

#define	as_float4(x) __builtin_astype((x), float4)

#define	as_float8(x) __builtin_astype((x), float8)

#define	as_float16(x) __builtin_astype((x), float16)

#define	as_size_t(x) __builtin_astype((x), size_t)

#define	as_ptrdiff_t(x) __builtin_astype((x), ptrdiff_t)

#define	as_intptr_t(x) __builtin_astype((x), intptr_t)

#define	as_uintptr_t(x) __builtin_astype((x), uintptr_t)

#define	__kernel_exec(X, typen)

#define	kernel_exec(X, typen)

Typedefs
typedef unsigned char	uchar
	An unsigned 8-bit integer.

typedef unsigned short	ushort
	An unsigned 16-bit integer.

typedef unsigned int	uint
	An unsigned 32-bit integer.

typedef unsigned long	ulong
	An unsigned 64-bit integer.

typedef __SIZE_TYPE__	size_t
	The unsigned integer type of the result of the sizeof operator.

typedef __PTRDIFF_TYPE__	ptrdiff_t
	A signed integer type that is the result of subtracting two pointers.

typedef __INTPTR_TYPE__	intptr_t
	A signed integer type with the property that any valid pointer to void can be converted to this type, then converted back to pointer to void, and the result will compare equal to the original pointer.

typedef __UINTPTR_TYPE__	uintptr_t
	An unsigned integer type with the property that any valid pointer to void can be converted to this type, then converted back to pointer to void, and the result will compare equal to the original pointer.

typedef char char2	__attribute__((ext_vector_type(2)))

typedef uint	cl_mem_fence_flags

typedef enum memory_scope	memory_scope

typedef enum memory_order	memory_order

typedef int	kernel_enqueue_flags_t

typedef int	clk_profiling_info

Enumerations
enum	memory_scope { memory_scope_work_item = __OPENCL_MEMORY_SCOPE_WORK_ITEM , memory_scope_work_group = __OPENCL_MEMORY_SCOPE_WORK_GROUP , memory_scope_device = __OPENCL_MEMORY_SCOPE_DEVICE }

enum	memory_order { memory_order_relaxed = __ATOMIC_RELAXED , memory_order_acquire = __ATOMIC_ACQUIRE , memory_order_release = __ATOMIC_RELEASE , memory_order_acq_rel = __ATOMIC_ACQ_REL , memory_order_relaxed = __ATOMIC_RELAXED , memory_order_consume = __ATOMIC_CONSUME , memory_order_acquire = __ATOMIC_ACQUIRE , memory_order_release = __ATOMIC_RELEASE , memory_order_acq_rel = __ATOMIC_ACQ_REL , memory_order_seq_cst = __ATOMIC_SEQ_CST }

◆ __half

◆ __kernel_exec

| #define __kernel_exec | ( | | X, | | ------------------------ | - | | ---------------------------------------------------------------------- | | | typen | | | | | ) | | | |

Value:

__kernel \

__attribute__((work_group_size_hint(X, 1, 1))) \

__attribute__((vec_type_hint(typen)))

Definition at line 680 of file opencl-c-base.h.

◆ __opencl_c_named_address_space_builtins

#define __opencl_c_named_address_space_builtins 1

◆ as_char

| #define as_char | ( | | x | ) | __builtin_astype((x), char) | | ---------------- | - | | - | - | ------------------------------ |

OpenCL v1.1/1.2/2.0 s6.2.4.2 - as_type operators Reinterprets a data type as another data type of the same size.

Definition at line 570 of file opencl-c-base.h.

◆ as_char16

| #define as_char16 | ( | | x | ) | __builtin_astype((x), char16) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_char2

| #define as_char2 | ( | | x | ) | __builtin_astype((x), char2) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_char3

| #define as_char3 | ( | | x | ) | __builtin_astype((x), char3) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_char4

| #define as_char4 | ( | | x | ) | __builtin_astype((x), char4) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_char8

| #define as_char8 | ( | | x | ) | __builtin_astype((x), char8) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_float

| #define as_float | ( | | x | ) | __builtin_astype((x), float) | | ----------------- | - | | - | - | -------------------------------------------------------------------------------------------------------------------------------------- |

◆ as_float16

| #define as_float16 | ( | | x | ) | __builtin_astype((x), float16) | | ------------------- | - | | - | - | --------------------------------- |

◆ as_float2

| #define as_float2 | ( | | x | ) | __builtin_astype((x), float2) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_float3

| #define as_float3 | ( | | x | ) | __builtin_astype((x), float3) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_float4

| #define as_float4 | ( | | x | ) | __builtin_astype((x), float4) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_float8

| #define as_float8 | ( | | x | ) | __builtin_astype((x), float8) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_int

| #define as_int | ( | | x | ) | __builtin_astype((x), int) | | --------------- | - | | - | - | ------------------------------------------------------------------------------------------------------------------------------------ |

◆ as_int16

| #define as_int16 | ( | | x | ) | __builtin_astype((x), int16) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_int2

| #define as_int2 | ( | | x | ) | __builtin_astype((x), int2) | | ---------------- | - | | - | - | ------------------------------ |

◆ as_int3

| #define as_int3 | ( | | x | ) | __builtin_astype((x), int3) | | ---------------- | - | | - | - | ------------------------------ |

◆ as_int4

| #define as_int4 | ( | | x | ) | __builtin_astype((x), int4) | | ---------------- | - | | - | - | ------------------------------ |

◆ as_int8

| #define as_int8 | ( | | x | ) | __builtin_astype((x), int8) | | ---------------- | - | | - | - | ------------------------------ |

◆ as_intptr_t

| #define as_intptr_t | ( | | x | ) | __builtin_astype((x), intptr_t) | | --------------------- | - | | - | - | ------------------------------------------------------------------------------------------------ |

◆ as_long

| #define as_long | ( | | x | ) | __builtin_astype((x), long) | | ---------------- | - | | - | - | ------------------------------ |

◆ as_long16

| #define as_long16 | ( | | x | ) | __builtin_astype((x), long16) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_long2

| #define as_long2 | ( | | x | ) | __builtin_astype((x), long2) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_long3

| #define as_long3 | ( | | x | ) | __builtin_astype((x), long3) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_long4

| #define as_long4 | ( | | x | ) | __builtin_astype((x), long4) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_long8

| #define as_long8 | ( | | x | ) | __builtin_astype((x), long8) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_ptrdiff_t

| #define as_ptrdiff_t | ( | | x | ) | __builtin_astype((x), ptrdiff_t) | | ---------------------- | - | | - | - | -------------------------------------------------------------------------------------------------------------------------- |

◆ as_short

| #define as_short | ( | | x | ) | __builtin_astype((x), short) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_short16

| #define as_short16 | ( | | x | ) | __builtin_astype((x), short16) | | ------------------- | - | | - | - | --------------------------------- |

◆ as_short2

| #define as_short2 | ( | | x | ) | __builtin_astype((x), short2) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_short3

| #define as_short3 | ( | | x | ) | __builtin_astype((x), short3) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_short4

| #define as_short4 | ( | | x | ) | __builtin_astype((x), short4) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_short8

| #define as_short8 | ( | | x | ) | __builtin_astype((x), short8) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_size_t

| #define as_size_t | ( | | x | ) | __builtin_astype((x), size_t) | | ------------------- | - | | - | - | -------------------------------------------------------------------------------------------------------------------- |

◆ as_uchar

| #define as_uchar | ( | | x | ) | __builtin_astype((x), uchar) | | ----------------- | - | | - | - | -------------------------------------------------------------------------------------------- |

◆ as_uchar16

| #define as_uchar16 | ( | | x | ) | __builtin_astype((x), uchar16) | | ------------------- | - | | - | - | --------------------------------- |

◆ as_uchar2

| #define as_uchar2 | ( | | x | ) | __builtin_astype((x), uchar2) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_uchar3

| #define as_uchar3 | ( | | x | ) | __builtin_astype((x), uchar3) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_uchar4

| #define as_uchar4 | ( | | x | ) | __builtin_astype((x), uchar4) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_uchar8

| #define as_uchar8 | ( | | x | ) | __builtin_astype((x), uchar8) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_uint

| #define as_uint | ( | | x | ) | __builtin_astype((x), uint) | | ---------------- | - | | - | - | ------------------------------------------------------------------------------------------- |

◆ as_uint16

| #define as_uint16 | ( | | x | ) | __builtin_astype((x), uint16) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_uint2

| #define as_uint2 | ( | | x | ) | __builtin_astype((x), uint2) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_uint3

| #define as_uint3 | ( | | x | ) | __builtin_astype((x), uint3) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_uint4

| #define as_uint4 | ( | | x | ) | __builtin_astype((x), uint4) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_uint8

| #define as_uint8 | ( | | x | ) | __builtin_astype((x), uint8) | | ----------------- | - | | - | - | ------------------------------- |

◆ as_uintptr_t

| #define as_uintptr_t | ( | | x | ) | __builtin_astype((x), uintptr_t) | | ---------------------- | - | | - | - | ------------------------------------------------------------------------------------------------- |

◆ as_ulong

| #define as_ulong | ( | | x | ) | __builtin_astype((x), ulong) | | ----------------- | - | | - | - | -------------------------------------------------------------------------------------------- |

◆ as_ulong16

| #define as_ulong16 | ( | | x | ) | __builtin_astype((x), ulong16) | | ------------------- | - | | - | - | --------------------------------- |

◆ as_ulong2

| #define as_ulong2 | ( | | x | ) | __builtin_astype((x), ulong2) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_ulong3

| #define as_ulong3 | ( | | x | ) | __builtin_astype((x), ulong3) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_ulong4

| #define as_ulong4 | ( | | x | ) | __builtin_astype((x), ulong4) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_ulong8

| #define as_ulong8 | ( | | x | ) | __builtin_astype((x), ulong8) | | ------------------ | - | | - | - | -------------------------------- |

◆ as_ushort

| #define as_ushort | ( | | x | ) | __builtin_astype((x), ushort) | | ------------------ | - | | - | - | --------------------------------------------------------------------------------------------- |

◆ as_ushort16

| #define as_ushort16 | ( | | x | ) | __builtin_astype((x), ushort16) | | -------------------- | - | | - | - | ---------------------------------- |

◆ as_ushort2

| #define as_ushort2 | ( | | x | ) | __builtin_astype((x), ushort2) | | ------------------- | - | | - | - | --------------------------------- |

◆ as_ushort3

| #define as_ushort3 | ( | | x | ) | __builtin_astype((x), ushort3) | | ------------------- | - | | - | - | --------------------------------- |

◆ as_ushort4

| #define as_ushort4 | ( | | x | ) | __builtin_astype((x), ushort4) | | ------------------- | - | | - | - | --------------------------------- |

◆ as_ushort8

| #define as_ushort8 | ( | | x | ) | __builtin_astype((x), ushort8) | | ------------------- | - | | - | - | --------------------------------- |

◆ ATOMIC_FLAG_INIT

#define ATOMIC_FLAG_INIT 0

◆ ATOMIC_VAR_INIT

| #define ATOMIC_VAR_INIT | ( | | x | ) | (x) | | ------------------------- | - | | - | - | --- |

◆ CHAR_BIT

◆ CHAR_MAX

◆ CHAR_MIN

◆ CL_COMPLETE

◆ CL_QUEUED

◆ CL_RUNNING

◆ CL_SUBMITTED

◆ CLK_A

◆ CLK_ABGR

◆ CLK_ADDRESS_CLAMP

#define CLK_ADDRESS_CLAMP 4

◆ CLK_ADDRESS_CLAMP_TO_EDGE

#define CLK_ADDRESS_CLAMP_TO_EDGE 2

◆ CLK_ADDRESS_MIRRORED_REPEAT

#define CLK_ADDRESS_MIRRORED_REPEAT 8

◆ CLK_ADDRESS_NONE

#define CLK_ADDRESS_NONE 0

◆ CLK_ADDRESS_REPEAT

#define CLK_ADDRESS_REPEAT 6

◆ CLK_ARGB

◆ CLK_BGRA

◆ CLK_DEPTH

◆ CLK_DEPTH_STENCIL

#define CLK_DEPTH_STENCIL 0x10BE

◆ CLK_DEVICE_QUEUE_FULL

#define CLK_DEVICE_QUEUE_FULL -161

◆ CLK_ENQUEUE_FAILURE

#define CLK_ENQUEUE_FAILURE -101

◆ CLK_ENQUEUE_FLAGS_NO_WAIT

#define CLK_ENQUEUE_FLAGS_NO_WAIT 0x0

◆ CLK_ENQUEUE_FLAGS_WAIT_KERNEL

#define CLK_ENQUEUE_FLAGS_WAIT_KERNEL 0x1

◆ CLK_ENQUEUE_FLAGS_WAIT_WORK_GROUP

#define CLK_ENQUEUE_FLAGS_WAIT_WORK_GROUP 0x2

◆ CLK_EVENT_ALLOCATION_FAILURE

#define CLK_EVENT_ALLOCATION_FAILURE -100

◆ CLK_FILTER_LINEAR

#define CLK_FILTER_LINEAR 0x20

◆ CLK_FILTER_NEAREST

#define CLK_FILTER_NEAREST 0x10

◆ CLK_FLOAT

◆ CLK_GLOBAL_MEM_FENCE

#define CLK_GLOBAL_MEM_FENCE 0x02

Queue a memory fence to ensure correct ordering of memory operations to global memory.

Definition at line 385 of file opencl-c-base.h.

◆ CLK_HALF_FLOAT

#define CLK_HALF_FLOAT 0x10DD

◆ CLK_IMAGE_MEM_FENCE

#define CLK_IMAGE_MEM_FENCE 0x04

Queue a memory fence to ensure correct ordering of memory operations between work-items of a work-group to image memory.

Definition at line 415 of file opencl-c-base.h.

◆ CLK_INTENSITY

#define CLK_INTENSITY 0x10B8

◆ CLK_INVALID_ARG_SIZE

#define CLK_INVALID_ARG_SIZE -51

◆ CLK_INVALID_EVENT_WAIT_LIST

#define CLK_INVALID_EVENT_WAIT_LIST -57

◆ CLK_INVALID_NDRANGE

#define CLK_INVALID_NDRANGE -160

◆ CLK_INVALID_QUEUE

#define CLK_INVALID_QUEUE -102

◆ CLK_LOCAL_MEM_FENCE

#define CLK_LOCAL_MEM_FENCE 0x01

Queue a memory fence to ensure correct ordering of memory operations to local memory.

Definition at line 379 of file opencl-c-base.h.

◆ CLK_LUMINANCE

#define CLK_LUMINANCE 0x10B9

◆ CLK_NORMALIZED_COORDS_FALSE

#define CLK_NORMALIZED_COORDS_FALSE 0

◆ CLK_NORMALIZED_COORDS_TRUE

#define CLK_NORMALIZED_COORDS_TRUE 1

◆ CLK_NULL_EVENT

#define CLK_NULL_EVENT (__builtin_astype(((__SIZE_MAX__)), clk_event_t))

◆ CLK_NULL_QUEUE

◆ CLK_NULL_RESERVE_ID

#define CLK_NULL_RESERVE_ID (__builtin_astype(((void*)(__SIZE_MAX__)), reserve_id_t))

◆ CLK_OUT_OF_RESOURCES

#define CLK_OUT_OF_RESOURCES -5

◆ CLK_PROFILING_COMMAND_EXEC_TIME

#define CLK_PROFILING_COMMAND_EXEC_TIME 0x1

◆ CLK_R

◆ CLK_RA

◆ CLK_RG

◆ CLK_RGB

◆ CLK_RGBA

◆ CLK_RGBx

◆ CLK_RGx

◆ CLK_Rx

◆ CLK_sBGRA

◆ CLK_SIGNED_INT16

#define CLK_SIGNED_INT16 0x10D8

◆ CLK_SIGNED_INT32

#define CLK_SIGNED_INT32 0x10D9

◆ CLK_SIGNED_INT8

#define CLK_SIGNED_INT8 0x10D7

◆ CLK_SNORM_INT16

#define CLK_SNORM_INT16 0x10D1

◆ CLK_SNORM_INT8

#define CLK_SNORM_INT8 0x10D0

◆ CLK_sRGB

◆ CLK_sRGBA

◆ CLK_sRGBx

◆ CLK_SUCCESS

◆ CLK_UNORM_INT16

#define CLK_UNORM_INT16 0x10D3

◆ CLK_UNORM_INT24

#define CLK_UNORM_INT24 0x10DF

◆ CLK_UNORM_INT8

#define CLK_UNORM_INT8 0x10D2

◆ CLK_UNORM_INT_101010

#define CLK_UNORM_INT_101010 0x10D6

◆ CLK_UNORM_INT_101010_2

#define CLK_UNORM_INT_101010_2 0x10E0

◆ CLK_UNORM_SHORT_555

#define CLK_UNORM_SHORT_555 0x10D5

◆ CLK_UNORM_SHORT_565

#define CLK_UNORM_SHORT_565 0x10D4

◆ CLK_UNSIGNED_INT16

#define CLK_UNSIGNED_INT16 0x10DB

◆ CLK_UNSIGNED_INT32

#define CLK_UNSIGNED_INT32 0x10DC

◆ CLK_UNSIGNED_INT8

#define CLK_UNSIGNED_INT8 0x10DA

◆ DBL_DIG

◆ DBL_EPSILON

#define DBL_EPSILON 0x1.0p-52

◆ DBL_MANT_DIG

◆ DBL_MAX

#define DBL_MAX 0x1.fffffffffffffp1023

◆ DBL_MAX_10_EXP

#define DBL_MAX_10_EXP +308

◆ DBL_MAX_EXP

#define DBL_MAX_EXP +1024

◆ DBL_MIN

#define DBL_MIN 0x1.0p-1022

◆ DBL_MIN_10_EXP

#define DBL_MIN_10_EXP -307

◆ DBL_MIN_EXP

#define DBL_MIN_EXP -1021

◆ DBL_RADIX

◆ FLT_DIG

◆ FLT_EPSILON

#define FLT_EPSILON 0x1.0p-23f

◆ FLT_MANT_DIG

◆ FLT_MAX

#define FLT_MAX 0x1.fffffep127f

◆ FLT_MAX_10_EXP

#define FLT_MAX_10_EXP +38

◆ FLT_MAX_EXP

◆ FLT_MIN

#define FLT_MIN 0x1.0p-126f

◆ FLT_MIN_10_EXP

#define FLT_MIN_10_EXP -37

◆ FLT_MIN_EXP

◆ FLT_RADIX

◆ FP_ILOGB0

◆ FP_ILOGBNAN

◆ HUGE_VAL

#define HUGE_VAL (__builtin_huge_val())

A positive double constant expression.

HUGE_VAL evaluates to +infinity. Used as an error value returned by the built-in math functions.

Definition at line 259 of file opencl-c-base.h.

◆ HUGE_VALF

#define HUGE_VALF (__builtin_huge_valf())

A positive float constant expression.

HUGE_VALF evaluates to +infinity. Used as an error value returned by the built-in math functions.

Definition at line 252 of file opencl-c-base.h.

◆ INFINITY

#define INFINITY (__builtin_inff())

A constant expression of type float representing positive or unsigned infinity.

Definition at line 265 of file opencl-c-base.h.

◆ INT_MAX

#define INT_MAX 2147483647

◆ INT_MIN

#define INT_MIN (-2147483647-1)

◆ kernel_exec

| #define kernel_exec | ( | | X, | | -------------------- | - | | ---------------------------------------------------------------------- | | | typen | | | | | ) | | | |

Value:

__kernel \

__attribute__((work_group_size_hint(X, 1, 1))) \

__attribute__((vec_type_hint(typen)))

Definition at line 684 of file opencl-c-base.h.

◆ LONG_MAX

#define LONG_MAX 0x7fffffffffffffffL

◆ LONG_MIN

#define LONG_MIN (-0x7fffffffffffffffL-1)

◆ M_1_PI

#define M_1_PI 0x1.45f306dc9c883p-2

◆ M_1_PI_F

#define M_1_PI_F 0.318309886183790671537767526745028724f

◆ M_2_PI

#define M_2_PI 0x1.45f306dc9c883p-1

◆ M_2_PI_F

#define M_2_PI_F 0.636619772367581343075535053490057448f

◆ M_2_SQRTPI

#define M_2_SQRTPI 0x1.20dd750429b6dp+0

◆ M_2_SQRTPI_F

#define M_2_SQRTPI_F 1.12837916709551257389615890312154517f

◆ M_E

#define M_E 0x1.5bf0a8b145769p+1

◆ M_E_F

#define M_E_F 2.71828182845904523536028747135266250f

◆ M_LN10

#define M_LN10 0x1.26bb1bbb55516p+1

◆ M_LN10_F

#define M_LN10_F 2.30258509299404568401799145468436421f

◆ M_LN2

#define M_LN2 0x1.62e42fefa39efp-1

◆ M_LN2_F

#define M_LN2_F 0.693147180559945309417232121458176568f

◆ M_LOG10E

#define M_LOG10E 0x1.bcb7b1526e50ep-2

◆ M_LOG10E_F

#define M_LOG10E_F 0.434294481903251827651128918916605082f

◆ M_LOG2E

#define M_LOG2E 0x1.71547652b82fep+0

◆ M_LOG2E_F

#define M_LOG2E_F 1.44269504088896340735992468100189214f

◆ M_PI

#define M_PI 0x1.921fb54442d18p+1

◆ M_PI_2

#define M_PI_2 0x1.921fb54442d18p+0

◆ M_PI_2_F

#define M_PI_2_F 1.57079632679489661923132169163975144f

◆ M_PI_4

#define M_PI_4 0x1.921fb54442d18p-1

◆ M_PI_4_F

#define M_PI_4_F 0.785398163397448309615660845819875721f

◆ M_PI_F

#define M_PI_F 3.14159265358979323846264338327950288f

◆ M_SQRT1_2

#define M_SQRT1_2 0x1.6a09e667f3bcdp-1

◆ M_SQRT1_2_F

#define M_SQRT1_2_F 0.707106781186547524400844362104849039f

◆ M_SQRT2

#define M_SQRT2 0x1.6a09e667f3bcdp+0

◆ M_SQRT2_F

#define M_SQRT2_F 1.41421356237309504880168872420969808f

◆ MAX_WORK_DIM

◆ MAXFLOAT

#define MAXFLOAT 0x1.fffffep127f

Value of maximum non-infinite single-precision floating-point number.

Definition at line 245 of file opencl-c-base.h.

◆ NAN

A constant expression of type float representing a quiet NaN.

Definition at line 270 of file opencl-c-base.h.

◆ SCHAR_MAX

◆ SCHAR_MIN

◆ SHRT_MAX

◆ SHRT_MIN

#define SHRT_MIN (-32768)

◆ UCHAR_MAX

◆ UINT_MAX

#define UINT_MAX 0xffffffff

◆ ULONG_MAX

#define ULONG_MAX 0xffffffffffffffffUL

◆ USHRT_MAX

◆ attribute

typedef float float16 __attribute__((ext_vector_type(16)))

◆ cl_mem_fence_flags

◆ clk_profiling_info

◆ intptr_t

A signed integer type with the property that any valid pointer to void can be converted to this type, then converted back to pointer to void, and the result will compare equal to the original pointer.

Definition at line 158 of file opencl-c-base.h.

◆ kernel_enqueue_flags_t

◆ memory_order

◆ memory_scope

◆ ptrdiff_t

A signed integer type that is the result of subtracting two pointers.

This is a 32-bit signed integer if CL_DEVICE_ADDRESS_BITS defined in table 4.3 is 32-bits and is a 64-bit signed integer if CL_DEVICE_ADDRESS_BITS is 64-bits.

Definition at line 151 of file opencl-c-base.h.

◆ size_t

The unsigned integer type of the result of the sizeof operator.

This is a 32-bit unsigned integer if CL_DEVICE_ADDRESS_BITS defined in table 4.3 is 32-bits and is a 64-bit unsigned integer if CL_DEVICE_ADDRESS_BITS is 64-bits.

Definition at line 143 of file opencl-c-base.h.

◆ uchar

◆ uint

◆ uintptr_t

An unsigned integer type with the property that any valid pointer to void can be converted to this type, then converted back to pointer to void, and the result will compare equal to the original pointer.

Definition at line 165 of file opencl-c-base.h.

◆ ulong

◆ ushort

◆ memory_order

Enumerator
memory_order_relaxed
memory_order_acquire
memory_order_release
memory_order_acq_rel
memory_order_relaxed
memory_order_consume
memory_order_acquire
memory_order_release
memory_order_acq_rel
memory_order_seq_cst

Definition at line 423 of file opencl-c-base.h.

◆ memory_scope

Enumerator
memory_scope_work_item
memory_scope_work_group
memory_scope_device

Definition at line 389 of file opencl-c-base.h.

◆ printf()

int printf	(	__constant const char *	st,
	...
)