[thirdparty/gcc.git] / include / gomp-constants.h

/* Communication between GCC and libgomp.

   Copyright (C) 2014-2024 Free Software Foundation, Inc.

   Contributed by Mentor Embedded.

   This file is part of the GNU Offloading and Multi Processing Library
   (libgomp).

   Libgomp is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   more details.

   Under Section 7 of GPL version 3, you are granted additional
   permissions described in the GCC Runtime Library Exception, version
   3.1, as published by the Free Software Foundation.

   You should have received a copy of the GNU General Public License and
   a copy of the GCC Runtime Library Exception along with this program;
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
   <http://www.gnu.org/licenses/>.  */

#ifndef GOMP_CONSTANTS_H
#define GOMP_CONSTANTS_H 1

/* Memory mapping types.  */

/* One byte.  */
#define GOMP_MAP_LAST			(1 << 8)

#define GOMP_MAP_FLAG_TO		(1 << 0)
#define GOMP_MAP_FLAG_FROM		(1 << 1)
/* Special map kinds, enumerated starting here.  */
#define GOMP_MAP_FLAG_SPECIAL_0		(1 << 2)
#define GOMP_MAP_FLAG_SPECIAL_1		(1 << 3)
#define GOMP_MAP_FLAG_SPECIAL_2		(1 << 4)
#define GOMP_MAP_FLAG_SPECIAL_3		(1 << 5)
#define GOMP_MAP_FLAG_SPECIAL_4		(1 << 6)
#define GOMP_MAP_FLAG_SPECIAL_5		(1 << 7)
#define GOMP_MAP_FLAG_SPECIAL		(GOMP_MAP_FLAG_SPECIAL_1 \
					 | GOMP_MAP_FLAG_SPECIAL_0)
#define GOMP_MAP_DEEP_COPY		(GOMP_MAP_FLAG_SPECIAL_4 \
					 | GOMP_MAP_FLAG_SPECIAL_2)
/* This value indicates the map was created implicitly according to
   OpenMP rules.  */
#define GOMP_MAP_IMPLICIT		(GOMP_MAP_FLAG_SPECIAL_3 \
					 | GOMP_MAP_FLAG_SPECIAL_4)
/* Mask for entire set of special map kind bits.  */
#define GOMP_MAP_FLAG_SPECIAL_BITS	(GOMP_MAP_FLAG_SPECIAL_0 \
					 | GOMP_MAP_FLAG_SPECIAL_1 \
					 | GOMP_MAP_FLAG_SPECIAL_2 \
					 | GOMP_MAP_FLAG_SPECIAL_3 \
					 | GOMP_MAP_FLAG_SPECIAL_4 \
					 | GOMP_MAP_FLAG_SPECIAL_5)
/* Flag to force a specific behavior (or else, trigger a run-time error).  */
#define GOMP_MAP_FLAG_FORCE		(GOMP_MAP_FLAG_SPECIAL_5)
#define GOMP_MAP_FLAG_PRESENT		(GOMP_MAP_FLAG_SPECIAL_5 \
					 | GOMP_MAP_FLAG_SPECIAL_0)
#define GOMP_MAP_FLAG_ALWAYS_PRESENT	(GOMP_MAP_FLAG_SPECIAL_2 \
					 | GOMP_MAP_FLAG_PRESENT)

enum gomp_map_kind
  {
    /* If not already present, allocate.  */
    GOMP_MAP_ALLOC =			0,
    /* ..., and copy to device.  */
    GOMP_MAP_TO =			(GOMP_MAP_ALLOC | GOMP_MAP_FLAG_TO),
    /* ..., and copy from device.  */
    GOMP_MAP_FROM =			(GOMP_MAP_ALLOC | GOMP_MAP_FLAG_FROM),
    /* ..., and copy to and from device.  */
    GOMP_MAP_TOFROM =			(GOMP_MAP_TO | GOMP_MAP_FROM),
    /* The following kind is an internal only map kind, used for pointer based
       array sections.  OMP_CLAUSE_SIZE for these is not the pointer size,
       which is implicitly POINTER_SIZE_UNITS, but the bias.  */
    GOMP_MAP_POINTER =			(GOMP_MAP_FLAG_SPECIAL_0 | 0),
    /* Also internal, behaves like GOMP_MAP_TO, but additionally any
       GOMP_MAP_POINTER records consecutive after it which have addresses
       falling into that range will not be ignored if GOMP_MAP_TO_PSET wasn't
       mapped already.
       For OpenACC attach operations (e.g. copyin of struct members),
       GOMP_MAP_TO_PSET is followed by a single GOMP_MAP_ATTACH mapping
       instead.  */
    GOMP_MAP_TO_PSET =			(GOMP_MAP_FLAG_SPECIAL_0 | 1),
    /* Must already be present.  */
    GOMP_MAP_FORCE_PRESENT =		(GOMP_MAP_FLAG_SPECIAL_0 | 2),
    /* Deallocate a mapping, without copying from device.  */
    GOMP_MAP_DELETE =			(GOMP_MAP_FLAG_SPECIAL_0 | 3),
    /* Is a device pointer.  OMP_CLAUSE_SIZE for these is unused; is implicitly
       POINTER_SIZE_UNITS.  */
    GOMP_MAP_FORCE_DEVICEPTR =		(GOMP_MAP_FLAG_SPECIAL_1 | 0),
    /* OpenACC device_resident.  */
    GOMP_MAP_DEVICE_RESIDENT =		(GOMP_MAP_FLAG_SPECIAL_1 | 1),
    /* OpenACC link.  */
    GOMP_MAP_LINK =			(GOMP_MAP_FLAG_SPECIAL_1 | 2),
    /* Use device data if present, fall back to host address otherwise.  */
    GOMP_MAP_IF_PRESENT =		(GOMP_MAP_FLAG_SPECIAL_1 | 3),
    /* Do not map, copy bits for firstprivate instead.  */
    GOMP_MAP_FIRSTPRIVATE =		(GOMP_MAP_FLAG_SPECIAL | 0),
    /* Similarly, but store the value in the pointer rather than
       pointed by the pointer.  */
    GOMP_MAP_FIRSTPRIVATE_INT =		(GOMP_MAP_FLAG_SPECIAL | 1),
    /* Pointer translate host address into device address and copy that
       back to host.  */
    GOMP_MAP_USE_DEVICE_PTR =		(GOMP_MAP_FLAG_SPECIAL | 2),
    /* Allocate a zero length array section.  Prefer next non-zero length
       mapping over previous non-zero length mapping over zero length mapping
       at the address.  If not already mapped, do nothing (and pointer translate
       to NULL).  */
    GOMP_MAP_ZERO_LEN_ARRAY_SECTION = 	(GOMP_MAP_FLAG_SPECIAL | 3),
    /* Allocate.  */
    GOMP_MAP_FORCE_ALLOC =		(GOMP_MAP_FLAG_FORCE | GOMP_MAP_ALLOC),
    /* ..., and copy to device.  */
    GOMP_MAP_FORCE_TO =			(GOMP_MAP_FLAG_FORCE | GOMP_MAP_TO),
    /* ..., and copy from device.  */
    GOMP_MAP_FORCE_FROM =		(GOMP_MAP_FLAG_FORCE | GOMP_MAP_FROM),
    /* ..., and copy to and from device.  */
    GOMP_MAP_FORCE_TOFROM =		(GOMP_MAP_FLAG_FORCE | GOMP_MAP_TOFROM),
    /* Like GOMP_MAP_USE_DEVICE_PTR above, translate a host to a device
       address.  If translation fails because the target is not mapped,
       continue using the host address. */
    GOMP_MAP_USE_DEVICE_PTR_IF_PRESENT = (GOMP_MAP_FLAG_SPECIAL_2 | 0),
    /* If not already present, allocate.  And unconditionally copy to
       device.  */
    GOMP_MAP_ALWAYS_TO =		(GOMP_MAP_FLAG_SPECIAL_2 | GOMP_MAP_TO),
    /* If not already present, allocate.  And unconditionally copy from
       device.  */
    GOMP_MAP_ALWAYS_FROM =		(GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_FROM),
    /* If not already present, allocate.  And unconditionally copy to and from
       device.  */
    GOMP_MAP_ALWAYS_TOFROM =		(GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_TOFROM),
    /* Must already be present, unconditionally copy to device.  */
    GOMP_MAP_ALWAYS_PRESENT_TO =	(GOMP_MAP_FLAG_ALWAYS_PRESENT
					 | GOMP_MAP_TO),
    /* Must already be present, unconditionally copy from device.  */
    GOMP_MAP_ALWAYS_PRESENT_FROM =	(GOMP_MAP_FLAG_ALWAYS_PRESENT
					 | GOMP_MAP_FROM),
    /* Must already be present, unconditionally copy to and from device.  */
    GOMP_MAP_ALWAYS_PRESENT_TOFROM =	(GOMP_MAP_FLAG_ALWAYS_PRESENT
					 | GOMP_MAP_TOFROM),
    /* Map a sparse struct; the address is the base of the structure, alignment
       it's required alignment, and size is the number of adjacent entries
       that belong to the struct.  The adjacent entries should be sorted by
       increasing address, so it is easy to determine lowest needed address
       (address of the first adjacent entry) and highest needed address
       (address of the last adjacent entry plus its size).  */
    GOMP_MAP_STRUCT =			(GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_FLAG_SPECIAL | 0),
    /* As above, but followed by an unordered list of adjacent entries.
       At present, this is used only to diagnose incorrect usage of variable
       indices into arrays of structs.  */
    GOMP_MAP_STRUCT_UNORD =		(GOMP_MAP_FLAG_SPECIAL_4
					 | GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_FLAG_SPECIAL | 0),
    /* On a location of a pointer/reference that is assumed to be already mapped
       earlier, store the translated address of the preceeding mapping.
       No refcount is bumped by this, and the store is done unconditionally.  */
    GOMP_MAP_ALWAYS_POINTER =		(GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_FLAG_SPECIAL | 1),
    /* Like GOMP_MAP_POINTER, but allow zero-length array section, i.e. set to
       NULL if target is not mapped.  */
    GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION
      =					(GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_FLAG_SPECIAL | 2),
    /* Forced deallocation of zero length array section.  */
    GOMP_MAP_DELETE_ZERO_LEN_ARRAY_SECTION
      =					(GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_FLAG_SPECIAL | 3),
    /* Decrement usage count and deallocate if zero.  */
    GOMP_MAP_RELEASE =			(GOMP_MAP_FLAG_SPECIAL_2
					 | GOMP_MAP_DELETE),
    /* The attach/detach mappings below use the OMP_CLAUSE_SIZE field as a
       bias.  This will typically be zero, except when mapping an array slice
       with a non-zero base.  In that case the bias will indicate the
       (positive) difference between the start of the actual mapped data and
       the "virtual" origin of the array.
       In OpenACC, attach a pointer to a mapped struct field.  */
    GOMP_MAP_ATTACH =			(GOMP_MAP_DEEP_COPY | 0),
    /* In OpenACC, detach a pointer to a mapped struct field.  */
    GOMP_MAP_DETACH =			(GOMP_MAP_DEEP_COPY | 1),
    /* In OpenACC, detach a pointer to a mapped struct field.  */
    GOMP_MAP_FORCE_DETACH =		(GOMP_MAP_DEEP_COPY
					 | GOMP_MAP_FLAG_FORCE | 1),

    /* Like GOMP_MAP_ATTACH, but allow attaching to zero-length array sections
       (i.e. set to NULL when array section is not mapped) Currently only used
       by OpenMP.  */
    GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION
      =					(GOMP_MAP_DEEP_COPY | 2),

    /* Internal to GCC, not used in libgomp.  */
    /* Do not map, but pointer assign a pointer instead.  */
    GOMP_MAP_FIRSTPRIVATE_POINTER =	(GOMP_MAP_LAST | 1),
    /* Do not map, but pointer assign a reference instead.  */
    GOMP_MAP_FIRSTPRIVATE_REFERENCE =	(GOMP_MAP_LAST | 2),
    /* An attach or detach operation.  Rewritten to the appropriate type during
       gimplification, depending on directive (i.e. "enter data" or
       parallel/kernels region vs. "exit data").  */
    GOMP_MAP_ATTACH_DETACH =		(GOMP_MAP_LAST | 3),
    /* Must already be present - all of following map to GOMP_MAP_FORCE_PRESENT
       as no data transfer is needed.  */
    GOMP_MAP_PRESENT_ALLOC =		(GOMP_MAP_LAST | 4),
    GOMP_MAP_PRESENT_TO =		(GOMP_MAP_LAST | 5),
    GOMP_MAP_PRESENT_FROM =		(GOMP_MAP_LAST | 6),
    GOMP_MAP_PRESENT_TOFROM =		(GOMP_MAP_LAST | 7)
  };

#define GOMP_MAP_COPY_TO_P(X) \
  ((!((X) & GOMP_MAP_FLAG_SPECIAL) || GOMP_MAP_PRESENT_P (X)) \
   && ((X) & GOMP_MAP_FLAG_TO))

#define GOMP_MAP_COPY_FROM_P(X) \
  ((!((X) & GOMP_MAP_FLAG_SPECIAL) || GOMP_MAP_PRESENT_P (X)) \
   && ((X) & GOMP_MAP_FLAG_FROM))

#define GOMP_MAP_ALWAYS_POINTER_P(X) \
  ((X) == GOMP_MAP_ALWAYS_POINTER)

#define GOMP_MAP_POINTER_P(X) \
  ((X) == GOMP_MAP_POINTER \
   || (X) == GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION)

#define GOMP_MAP_ALWAYS_TO_P(X) \
  (((X) == GOMP_MAP_ALWAYS_TO) || ((X) == GOMP_MAP_ALWAYS_TOFROM) \
   || ((X) == GOMP_MAP_ALWAYS_PRESENT_TO) \
   || ((X) == GOMP_MAP_ALWAYS_PRESENT_TOFROM))

#define GOMP_MAP_ALWAYS_FROM_P(X) \
  (((X) == GOMP_MAP_ALWAYS_FROM) || ((X) == GOMP_MAP_ALWAYS_TOFROM) \
   || ((X) == GOMP_MAP_ALWAYS_PRESENT_FROM) \
   || ((X) == GOMP_MAP_ALWAYS_PRESENT_TOFROM))

#define GOMP_MAP_ALWAYS_P(X) \
  (GOMP_MAP_ALWAYS_TO_P (X) || GOMP_MAP_ALWAYS_FROM_P (X))

#define GOMP_MAP_IMPLICIT_P(X) \
  (((X) & GOMP_MAP_FLAG_SPECIAL_BITS) == GOMP_MAP_IMPLICIT)

#define GOMP_MAP_FORCE_P(X) \
  (((X) & GOMP_MAP_FLAG_SPECIAL_BITS) == GOMP_MAP_FLAG_FORCE)

#define GOMP_MAP_PRESENT_P(X) \
  (((X) & GOMP_MAP_FLAG_PRESENT) == GOMP_MAP_FLAG_PRESENT \
   || (X) == GOMP_MAP_FORCE_PRESENT)


/* Asynchronous behavior.  Keep in sync with
   libgomp/{openacc.h,openacc.f90,openacc_lib.h}:acc_async_t.  */

#define GOMP_ASYNC_NOVAL		-1
#define GOMP_ASYNC_SYNC			-2


/* Device codes.  Keep in sync with
   libgomp/{openacc.h,openacc.f90,openacc_lib.h}:acc_device_t as well as
   libgomp/libgomp-plugin.h.  */
#define GOMP_DEVICE_NONE		0
#define GOMP_DEVICE_DEFAULT		1
#define GOMP_DEVICE_HOST		2
/* #define GOMP_DEVICE_HOST_NONSHM	3 removed.  */
#define GOMP_DEVICE_NOT_HOST		4
#define GOMP_DEVICE_NVIDIA_PTX		5
/* #define GOMP_DEVICE_INTEL_MIC	6 removed.  */
/* #define GOMP_DEVICE_HSA		7 removed.  */
#define GOMP_DEVICE_GCN			8

/* We have a compatibility issue.  OpenMP 5.2 introduced
   omp_initial_device with value of -1 which clashes with our
   GOMP_DEVICE_ICV, so we need to remap user supplied device
   ids, -1 (aka omp_initial_device) to GOMP_DEVICE_HOST_FALLBACK,
   and -2 (one of many non-conforming device numbers, but with
   OMP_TARGET_OFFLOAD=mandatory needs to be treated a
   omp_invalid_device) to -3 (so that for dev_num >= -2U we can
   subtract 1).  -4 is then what we use for omp_invalid_device,
   which unlike the other non-conforming device numbers results
   in fatal error regardless of OMP_TARGET_OFFLOAD.  */
#define GOMP_DEVICE_ICV			-1
#define GOMP_DEVICE_HOST_FALLBACK	-2
#define GOMP_DEVICE_INVALID		-4

/* GOMP_task/GOMP_taskloop* flags argument.  */
#define GOMP_TASK_FLAG_UNTIED		(1 << 0)
#define GOMP_TASK_FLAG_FINAL		(1 << 1)
#define GOMP_TASK_FLAG_MERGEABLE	(1 << 2)
#define GOMP_TASK_FLAG_DEPEND		(1 << 3)
#define GOMP_TASK_FLAG_PRIORITY		(1 << 4)
#define GOMP_TASK_FLAG_UP		(1 << 8)
#define GOMP_TASK_FLAG_GRAINSIZE	(1 << 9)
#define GOMP_TASK_FLAG_IF		(1 << 10)
#define GOMP_TASK_FLAG_NOGROUP		(1 << 11)
#define GOMP_TASK_FLAG_REDUCTION	(1 << 12)
#define GOMP_TASK_FLAG_DETACH		(1 << 13)
#define GOMP_TASK_FLAG_STRICT		(1 << 14)

/* GOMP_target{_ext,update_ext,enter_exit_data} flags argument.  */
#define GOMP_TARGET_FLAG_NOWAIT		(1 << 0)
#define GOMP_TARGET_FLAG_EXIT_DATA	(1 << 1)
/* Internal to libgomp.  */
#define GOMP_TARGET_FLAG_UPDATE		(1U << 31)


/* OpenACC construct flags.  */

/* Force host fallback execution.  */
#define GOACC_FLAG_HOST_FALLBACK	(1 << 0)
/* Execute on local device (i.e. host multicore CPU).  */
#define GOACC_FLAG_LOCAL_DEVICE 	(1 << 1)

/* For legacy reasons, in the ABI, the GOACC_FLAGs are encoded as an inverted
   bitmask.  */
#define GOACC_FLAGS_MARSHAL_OP		BIT_NOT_EXPR
#define GOACC_FLAGS_UNMARSHAL(X)	(~(X))


/* Versions of libgomp and device-specific plugins.  GOMP_VERSION
   should be incremented whenever an ABI-incompatible change is introduced
   to the plugin interface defined in libgomp/libgomp.h.  */
#define GOMP_VERSION	3
#define GOMP_VERSION_NVIDIA_PTX 1
#define GOMP_VERSION_GCN 3

#define GOMP_VERSION_PACK(LIB, DEV) (((LIB) << 16) | (DEV))
#define GOMP_VERSION_LIB(PACK) (((PACK) >> 16) & 0xffff)
#define GOMP_VERSION_DEV(PACK) ((PACK) & 0xffff)

#define GOMP_VERSION_SUPPORTS_INDIRECT_FUNCS(VER) (GOMP_VERSION_LIB(VER) >= 3)

#define GOMP_DIM_GANG	0
#define GOMP_DIM_WORKER	1
#define GOMP_DIM_VECTOR	2
#define GOMP_DIM_MAX	3
#define GOMP_DIM_MASK(X) (1u << (X))

/* Varadic launch arguments.  End of list is marked by a zero.  */
#define GOMP_LAUNCH_DIM		1  /* Launch dimensions, op = mask */
#define GOMP_LAUNCH_ASYNC	2  /* Async, op = cst val if not MAX  */
#define GOMP_LAUNCH_WAIT	3  /* Waits, op = num waits.  */
#define GOMP_LAUNCH_CODE_SHIFT	28
#define GOMP_LAUNCH_DEVICE_SHIFT 16
#define GOMP_LAUNCH_OP_SHIFT 0
#define GOMP_LAUNCH_PACK(CODE,DEVICE,OP)	\
  (((CODE) << GOMP_LAUNCH_CODE_SHIFT)		\
   | ((DEVICE) << GOMP_LAUNCH_DEVICE_SHIFT)	\
   | ((OP) << GOMP_LAUNCH_OP_SHIFT))
#define GOMP_LAUNCH_CODE(X) (((X) >> GOMP_LAUNCH_CODE_SHIFT) & 0xf)
#define GOMP_LAUNCH_DEVICE(X) (((X) >> GOMP_LAUNCH_DEVICE_SHIFT) & 0xfff)
#define GOMP_LAUNCH_OP(X) (((X) >> GOMP_LAUNCH_OP_SHIFT) & 0xffff)
#define GOMP_LAUNCH_OP_MAX 0xffff

/* Bitmask to apply in order to find out the intended device of a target
   argument.  */
#define GOMP_TARGET_ARG_DEVICE_MASK		((1 << 7) - 1)
/* The target argument is significant for all devices.  */
#define GOMP_TARGET_ARG_DEVICE_ALL		0

/* Flag set when the subsequent element in the device-specific argument
   values.  */
#define GOMP_TARGET_ARG_SUBSEQUENT_PARAM	(1 << 7)

/* Bitmask to apply to a target argument to find out the value identifier.  */
#define GOMP_TARGET_ARG_ID_MASK			(((1 << 8) - 1) << 8)
/* Target argument index of NUM_TEAMS.  */
#define GOMP_TARGET_ARG_NUM_TEAMS		(1 << 8)
/* Target argument index of THREAD_LIMIT.  */
#define GOMP_TARGET_ARG_THREAD_LIMIT		(2 << 8)

/* If the value is directly embeded in target argument, it should be a 16-bit
   at most and shifted by this many bits.  */
#define GOMP_TARGET_ARG_VALUE_SHIFT		16

/* Dependence types in omp_depend_t objects.  */
#define GOMP_DEPEND_IN			1
#define GOMP_DEPEND_OUT			2
#define GOMP_DEPEND_INOUT		3
#define GOMP_DEPEND_MUTEXINOUTSET	4
#define GOMP_DEPEND_INOUTSET		5

/* Flag values for OpenMP 'requires' directive features.  */
#define GOMP_REQUIRES_UNIFIED_ADDRESS       0x10
#define GOMP_REQUIRES_UNIFIED_SHARED_MEMORY 0x20
#define GOMP_REQUIRES_REVERSE_OFFLOAD       0x80
#define GOMP_REQUIRES_TARGET_USED           0x200

/* HSA specific data structures.  */

/* Identifiers of device-specific target arguments.  */
#define GOMP_TARGET_ARG_HSA_KERNEL_ATTRIBUTES	(1 << 8)

#endif
Commit	Line	Data
41dbbb37 TS	1	/* Communication between GCC and libgomp.
41dbbb37 TS	2
a945c346	3	Copyright (C) 2014-2024 Free Software Foundation, Inc.
41dbbb37 TS	4
	5	Contributed by Mentor Embedded.
	6
	7	This file is part of the GNU Offloading and Multi Processing Library
	8	(libgomp).
	9
	10	Libgomp is free software; you can redistribute it and/or modify it
	11	under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 3, or (at your option)
	13	any later version.
	14
	15	Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
	16	WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	18	more details.
	19
	20	Under Section 7 of GPL version 3, you are granted additional
	21	permissions described in the GCC Runtime Library Exception, version
	22	3.1, as published by the Free Software Foundation.
	23
	24	You should have received a copy of the GNU General Public License and
	25	a copy of the GCC Runtime Library Exception along with this program;
	26	see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	27	<http://www.gnu.org/licenses/>. */
	28
	29	#ifndef GOMP_CONSTANTS_H
	30	#define GOMP_CONSTANTS_H 1
	31
	32	/* Memory mapping types. */
	33
	34	/* One byte. */
	35	#define GOMP_MAP_LAST (1 << 8)
	36
	37	#define GOMP_MAP_FLAG_TO (1 << 0)
	38	#define GOMP_MAP_FLAG_FROM (1 << 1)
	39	/* Special map kinds, enumerated starting here. */
	40	#define GOMP_MAP_FLAG_SPECIAL_0 (1 << 2)
	41	#define GOMP_MAP_FLAG_SPECIAL_1 (1 << 3)
e01d41e5	42	#define GOMP_MAP_FLAG_SPECIAL_2 (1 << 4)
b7e20480	43	#define GOMP_MAP_FLAG_SPECIAL_3 (1 << 5)
8e7e71ff	44	#define GOMP_MAP_FLAG_SPECIAL_4 (1 << 6)
4ede915d	45	#define GOMP_MAP_FLAG_SPECIAL_5 (1 << 7)
41dbbb37 TS	46	#define GOMP_MAP_FLAG_SPECIAL (GOMP_MAP_FLAG_SPECIAL_1 \
41dbbb37 TS	47	\| GOMP_MAP_FLAG_SPECIAL_0)
8e7e71ff JB	48	#define GOMP_MAP_DEEP_COPY (GOMP_MAP_FLAG_SPECIAL_4 \
8e7e71ff JB	49	\| GOMP_MAP_FLAG_SPECIAL_2)
b7e20480 CLT	50	/* This value indicates the map was created implicitly according to
	51	OpenMP rules. */
	52	#define GOMP_MAP_IMPLICIT (GOMP_MAP_FLAG_SPECIAL_3 \
	53	\| GOMP_MAP_FLAG_SPECIAL_4)
	54	/* Mask for entire set of special map kind bits. */
	55	#define GOMP_MAP_FLAG_SPECIAL_BITS (GOMP_MAP_FLAG_SPECIAL_0 \
	56	\| GOMP_MAP_FLAG_SPECIAL_1 \
	57	\| GOMP_MAP_FLAG_SPECIAL_2 \
	58	\| GOMP_MAP_FLAG_SPECIAL_3 \
4ede915d TB	59	\| GOMP_MAP_FLAG_SPECIAL_4 \
4ede915d TB	60	\| GOMP_MAP_FLAG_SPECIAL_5)
41dbbb37	61	/* Flag to force a specific behavior (or else, trigger a run-time error). */
4ede915d TB	62	#define GOMP_MAP_FLAG_FORCE (GOMP_MAP_FLAG_SPECIAL_5)
	63	#define GOMP_MAP_FLAG_PRESENT (GOMP_MAP_FLAG_SPECIAL_5 \
	64	\| GOMP_MAP_FLAG_SPECIAL_0)
	65	#define GOMP_MAP_FLAG_ALWAYS_PRESENT (GOMP_MAP_FLAG_SPECIAL_2 \
	66	\| GOMP_MAP_FLAG_PRESENT)
41dbbb37 TS	67
	68	enum gomp_map_kind
	69	{
	70	/* If not already present, allocate. */
	71	GOMP_MAP_ALLOC = 0,
	72	/* ..., and copy to device. */
	73	GOMP_MAP_TO = (GOMP_MAP_ALLOC \| GOMP_MAP_FLAG_TO),
	74	/* ..., and copy from device. */
	75	GOMP_MAP_FROM = (GOMP_MAP_ALLOC \| GOMP_MAP_FLAG_FROM),
	76	/* ..., and copy to and from device. */
	77	GOMP_MAP_TOFROM = (GOMP_MAP_TO \| GOMP_MAP_FROM),
	78	/* The following kind is an internal only map kind, used for pointer based
	79	array sections. OMP_CLAUSE_SIZE for these is not the pointer size,
	80	which is implicitly POINTER_SIZE_UNITS, but the bias. */
	81	GOMP_MAP_POINTER = (GOMP_MAP_FLAG_SPECIAL_0 \| 0),
	82	/* Also internal, behaves like GOMP_MAP_TO, but additionally any
	83	GOMP_MAP_POINTER records consecutive after it which have addresses
	84	falling into that range will not be ignored if GOMP_MAP_TO_PSET wasn't
8d2e5026 JB	85	mapped already.
	86	For OpenACC attach operations (e.g. copyin of struct members),
	87	GOMP_MAP_TO_PSET is followed by a single GOMP_MAP_ATTACH mapping
	88	instead. */
41dbbb37 TS	89	GOMP_MAP_TO_PSET = (GOMP_MAP_FLAG_SPECIAL_0 \| 1),
	90	/* Must already be present. */
	91	GOMP_MAP_FORCE_PRESENT = (GOMP_MAP_FLAG_SPECIAL_0 \| 2),
	92	/* Deallocate a mapping, without copying from device. */
91106e84	93	GOMP_MAP_DELETE = (GOMP_MAP_FLAG_SPECIAL_0 \| 3),
41dbbb37 TS	94	/* Is a device pointer. OMP_CLAUSE_SIZE for these is unused; is implicitly
	95	POINTER_SIZE_UNITS. */
	96	GOMP_MAP_FORCE_DEVICEPTR = (GOMP_MAP_FLAG_SPECIAL_1 \| 0),
6e232ba4 JN	97	/* OpenACC device_resident. */
	98	GOMP_MAP_DEVICE_RESIDENT = (GOMP_MAP_FLAG_SPECIAL_1 \| 1),
	99	/* OpenACC link. */
	100	GOMP_MAP_LINK = (GOMP_MAP_FLAG_SPECIAL_1 \| 2),
a6163563	101	/* Use device data if present, fall back to host address otherwise. */
d5c23c6c	102	GOMP_MAP_IF_PRESENT = (GOMP_MAP_FLAG_SPECIAL_1 \| 3),
cbdce905	103	/* Do not map, copy bits for firstprivate instead. */
d9a6bd32 JJ	104	GOMP_MAP_FIRSTPRIVATE = (GOMP_MAP_FLAG_SPECIAL \| 0),
	105	/* Similarly, but store the value in the pointer rather than
	106	pointed by the pointer. */
	107	GOMP_MAP_FIRSTPRIVATE_INT = (GOMP_MAP_FLAG_SPECIAL \| 1),
	108	/* Pointer translate host address into device address and copy that
	109	back to host. */
	110	GOMP_MAP_USE_DEVICE_PTR = (GOMP_MAP_FLAG_SPECIAL \| 2),
	111	/* Allocate a zero length array section. Prefer next non-zero length
	112	mapping over previous non-zero length mapping over zero length mapping
	113	at the address. If not already mapped, do nothing (and pointer translate
	114	to NULL). */
	115	GOMP_MAP_ZERO_LEN_ARRAY_SECTION = (GOMP_MAP_FLAG_SPECIAL \| 3),
41dbbb37 TS	116	/* Allocate. */
	117	GOMP_MAP_FORCE_ALLOC = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_ALLOC),
	118	/* ..., and copy to device. */
	119	GOMP_MAP_FORCE_TO = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_TO),
	120	/* ..., and copy from device. */
	121	GOMP_MAP_FORCE_FROM = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_FROM),
	122	/* ..., and copy to and from device. */
d9a6bd32	123	GOMP_MAP_FORCE_TOFROM = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_TOFROM),
d5c23c6c TB	124	/* Like GOMP_MAP_USE_DEVICE_PTR above, translate a host to a device
	125	address. If translation fails because the target is not mapped,
	126	continue using the host address. */
	127	GOMP_MAP_USE_DEVICE_PTR_IF_PRESENT = (GOMP_MAP_FLAG_SPECIAL_2 \| 0),
d9a6bd32 JJ	128	/* If not already present, allocate. And unconditionally copy to
d9a6bd32 JJ	129	device. */
e01d41e5	130	GOMP_MAP_ALWAYS_TO = (GOMP_MAP_FLAG_SPECIAL_2 \| GOMP_MAP_TO),
d9a6bd32 JJ	131	/* If not already present, allocate. And unconditionally copy from
d9a6bd32 JJ	132	device. */
e01d41e5 JJ	133	GOMP_MAP_ALWAYS_FROM = (GOMP_MAP_FLAG_SPECIAL_2
e01d41e5 JJ	134	\| GOMP_MAP_FROM),
d9a6bd32 JJ	135	/* If not already present, allocate. And unconditionally copy to and from
d9a6bd32 JJ	136	device. */
e01d41e5 JJ	137	GOMP_MAP_ALWAYS_TOFROM = (GOMP_MAP_FLAG_SPECIAL_2
e01d41e5 JJ	138	\| GOMP_MAP_TOFROM),
4ede915d TB	139	/* Must already be present, unconditionally copy to device. */
	140	GOMP_MAP_ALWAYS_PRESENT_TO = (GOMP_MAP_FLAG_ALWAYS_PRESENT
	141	\| GOMP_MAP_TO),
	142	/* Must already be present, unconditionally copy from device. */
	143	GOMP_MAP_ALWAYS_PRESENT_FROM = (GOMP_MAP_FLAG_ALWAYS_PRESENT
	144	\| GOMP_MAP_FROM),
	145	/* Must already be present, unconditionally copy to and from device. */
	146	GOMP_MAP_ALWAYS_PRESENT_TOFROM = (GOMP_MAP_FLAG_ALWAYS_PRESENT
	147	\| GOMP_MAP_TOFROM),
d9a6bd32 JJ	148	/* Map a sparse struct; the address is the base of the structure, alignment
	149	it's required alignment, and size is the number of adjacent entries
	150	that belong to the struct. The adjacent entries should be sorted by
	151	increasing address, so it is easy to determine lowest needed address
	152	(address of the first adjacent entry) and highest needed address
	153	(address of the last adjacent entry plus its size). */
e01d41e5	154	GOMP_MAP_STRUCT = (GOMP_MAP_FLAG_SPECIAL_2
d9a6bd32	155	\| GOMP_MAP_FLAG_SPECIAL \| 0),
f5745dc1 JB	156	/* As above, but followed by an unordered list of adjacent entries.
	157	At present, this is used only to diagnose incorrect usage of variable
	158	indices into arrays of structs. */
	159	GOMP_MAP_STRUCT_UNORD = (GOMP_MAP_FLAG_SPECIAL_4
	160	\| GOMP_MAP_FLAG_SPECIAL_2
	161	\| GOMP_MAP_FLAG_SPECIAL \| 0),
e01d41e5 JJ	162	/* On a location of a pointer/reference that is assumed to be already mapped
	163	earlier, store the translated address of the preceeding mapping.
	164	No refcount is bumped by this, and the store is done unconditionally. */
	165	GOMP_MAP_ALWAYS_POINTER = (GOMP_MAP_FLAG_SPECIAL_2
	166	\| GOMP_MAP_FLAG_SPECIAL \| 1),
0ab29cf0 CLT	167	/* Like GOMP_MAP_POINTER, but allow zero-length array section, i.e. set to
	168	NULL if target is not mapped. */
	169	GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION
	170	= (GOMP_MAP_FLAG_SPECIAL_2
	171	\| GOMP_MAP_FLAG_SPECIAL \| 2),
d9a6bd32 JJ	172	/* Forced deallocation of zero length array section. */
d9a6bd32 JJ	173	GOMP_MAP_DELETE_ZERO_LEN_ARRAY_SECTION
e01d41e5	174	= (GOMP_MAP_FLAG_SPECIAL_2
d9a6bd32	175	\| GOMP_MAP_FLAG_SPECIAL \| 3),
d9a6bd32	176	/* Decrement usage count and deallocate if zero. */
e01d41e5	177	GOMP_MAP_RELEASE = (GOMP_MAP_FLAG_SPECIAL_2
91106e84	178	\| GOMP_MAP_DELETE),
0d00fe40 JB	179	/* The attach/detach mappings below use the OMP_CLAUSE_SIZE field as a
	180	bias. This will typically be zero, except when mapping an array slice
	181	with a non-zero base. In that case the bias will indicate the
	182	(positive) difference between the start of the actual mapped data and
	183	the "virtual" origin of the array.
	184	In OpenACC, attach a pointer to a mapped struct field. */
8e7e71ff JB	185	GOMP_MAP_ATTACH = (GOMP_MAP_DEEP_COPY \| 0),
	186	/* In OpenACC, detach a pointer to a mapped struct field. */
	187	GOMP_MAP_DETACH = (GOMP_MAP_DEEP_COPY \| 1),
	188	/* In OpenACC, detach a pointer to a mapped struct field. */
	189	GOMP_MAP_FORCE_DETACH = (GOMP_MAP_DEEP_COPY
	190	\| GOMP_MAP_FLAG_FORCE \| 1),
d9a6bd32	191
0ab29cf0 CLT	192	/* Like GOMP_MAP_ATTACH, but allow attaching to zero-length array sections
	193	(i.e. set to NULL when array section is not mapped) Currently only used
	194	by OpenMP. */
	195	GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION
	196	= (GOMP_MAP_DEEP_COPY \| 2),
	197
d9a6bd32 JJ	198	/* Internal to GCC, not used in libgomp. */
d9a6bd32 JJ	199	/* Do not map, but pointer assign a pointer instead. */
e01d41e5 JJ	200	GOMP_MAP_FIRSTPRIVATE_POINTER = (GOMP_MAP_LAST \| 1),
e01d41e5 JJ	201	/* Do not map, but pointer assign a reference instead. */
4fd872bc JB	202	GOMP_MAP_FIRSTPRIVATE_REFERENCE = (GOMP_MAP_LAST \| 2),
	203	/* An attach or detach operation. Rewritten to the appropriate type during
	204	gimplification, depending on directive (i.e. "enter data" or
	205	parallel/kernels region vs. "exit data"). */
38944ec2 TB	206	GOMP_MAP_ATTACH_DETACH = (GOMP_MAP_LAST \| 3),
	207	/* Must already be present - all of following map to GOMP_MAP_FORCE_PRESENT
	208	as no data transfer is needed. */
	209	GOMP_MAP_PRESENT_ALLOC = (GOMP_MAP_LAST \| 4),
	210	GOMP_MAP_PRESENT_TO = (GOMP_MAP_LAST \| 5),
	211	GOMP_MAP_PRESENT_FROM = (GOMP_MAP_LAST \| 6),
	212	GOMP_MAP_PRESENT_TOFROM = (GOMP_MAP_LAST \| 7)
41dbbb37 TS	213	};
	214
	215	#define GOMP_MAP_COPY_TO_P(X) \
4ede915d	216	((!((X) & GOMP_MAP_FLAG_SPECIAL) \|\| GOMP_MAP_PRESENT_P (X)) \
41dbbb37 TS	217	&& ((X) & GOMP_MAP_FLAG_TO))
	218
	219	#define GOMP_MAP_COPY_FROM_P(X) \
4ede915d	220	((!((X) & GOMP_MAP_FLAG_SPECIAL) \|\| GOMP_MAP_PRESENT_P (X)) \
41dbbb37 TS	221	&& ((X) & GOMP_MAP_FLAG_FROM))
41dbbb37 TS	222
972da557 TB	223	#define GOMP_MAP_ALWAYS_POINTER_P(X) \
	224	((X) == GOMP_MAP_ALWAYS_POINTER)
	225
41dbbb37	226	#define GOMP_MAP_POINTER_P(X) \
0ab29cf0 CLT	227	((X) == GOMP_MAP_POINTER \
0ab29cf0 CLT	228	\|\| (X) == GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION)
41dbbb37	229
d9a6bd32	230	#define GOMP_MAP_ALWAYS_TO_P(X) \
4ede915d TB	231	(((X) == GOMP_MAP_ALWAYS_TO) \|\| ((X) == GOMP_MAP_ALWAYS_TOFROM) \
	232	\|\| ((X) == GOMP_MAP_ALWAYS_PRESENT_TO) \
	233	\|\| ((X) == GOMP_MAP_ALWAYS_PRESENT_TOFROM))
d9a6bd32 JJ	234
d9a6bd32 JJ	235	#define GOMP_MAP_ALWAYS_FROM_P(X) \
4ede915d TB	236	(((X) == GOMP_MAP_ALWAYS_FROM) \|\| ((X) == GOMP_MAP_ALWAYS_TOFROM) \
	237	\|\| ((X) == GOMP_MAP_ALWAYS_PRESENT_FROM) \
	238	\|\| ((X) == GOMP_MAP_ALWAYS_PRESENT_TOFROM))
d9a6bd32	239
e01d41e5	240	#define GOMP_MAP_ALWAYS_P(X) \
4ede915d	241	(GOMP_MAP_ALWAYS_TO_P (X) \|\| GOMP_MAP_ALWAYS_FROM_P (X))
e01d41e5	242
b7e20480 CLT	243	#define GOMP_MAP_IMPLICIT_P(X) \
	244	(((X) & GOMP_MAP_FLAG_SPECIAL_BITS) == GOMP_MAP_IMPLICIT)
	245
4ede915d TB	246	#define GOMP_MAP_FORCE_P(X) \
	247	(((X) & GOMP_MAP_FLAG_SPECIAL_BITS) == GOMP_MAP_FLAG_FORCE)
	248
	249	#define GOMP_MAP_PRESENT_P(X) \
38944ec2 TB	250	(((X) & GOMP_MAP_FLAG_PRESENT) == GOMP_MAP_FLAG_PRESENT \
38944ec2 TB	251	\|\| (X) == GOMP_MAP_FORCE_PRESENT)
4ede915d	252
41dbbb37 TS	253
	254	/* Asynchronous behavior. Keep in sync with
	255	libgomp/{openacc.h,openacc.f90,openacc_lib.h}:acc_async_t. */
	256
	257	#define GOMP_ASYNC_NOVAL -1
	258	#define GOMP_ASYNC_SYNC -2
	259
	260
	261	/* Device codes. Keep in sync with
	262	libgomp/{openacc.h,openacc.f90,openacc_lib.h}:acc_device_t as well as
b97e78b7	263	libgomp/libgomp-plugin.h. */
41dbbb37 TS	264	#define GOMP_DEVICE_NONE 0
	265	#define GOMP_DEVICE_DEFAULT 1
	266	#define GOMP_DEVICE_HOST 2
b97e78b7	267	/* #define GOMP_DEVICE_HOST_NONSHM 3 removed. */
41dbbb37 TS	268	#define GOMP_DEVICE_NOT_HOST 4
41dbbb37 TS	269	#define GOMP_DEVICE_NVIDIA_PTX 5
e4cba494	270	/* #define GOMP_DEVICE_INTEL_MIC 6 removed. */
12d9f5af	271	/* #define GOMP_DEVICE_HSA 7 removed. */
fa499995	272	#define GOMP_DEVICE_GCN 8
41dbbb37	273
1158fe43 JJ	274	/* We have a compatibility issue. OpenMP 5.2 introduced
	275	omp_initial_device with value of -1 which clashes with our
	276	GOMP_DEVICE_ICV, so we need to remap user supplied device
	277	ids, -1 (aka omp_initial_device) to GOMP_DEVICE_HOST_FALLBACK,
	278	and -2 (one of many non-conforming device numbers, but with
	279	OMP_TARGET_OFFLOAD=mandatory needs to be treated a
	280	omp_invalid_device) to -3 (so that for dev_num >= -2U we can
	281	subtract 1). -4 is then what we use for omp_invalid_device,
	282	which unlike the other non-conforming device numbers results
	283	in fatal error regardless of OMP_TARGET_OFFLOAD. */
41dbbb37 TS	284	#define GOMP_DEVICE_ICV -1
41dbbb37 TS	285	#define GOMP_DEVICE_HOST_FALLBACK -2
1158fe43	286	#define GOMP_DEVICE_INVALID -4
41dbbb37	287
d9a6bd32 JJ	288	/* GOMP_task/GOMP_taskloop* flags argument. */
	289	#define GOMP_TASK_FLAG_UNTIED (1 << 0)
	290	#define GOMP_TASK_FLAG_FINAL (1 << 1)
	291	#define GOMP_TASK_FLAG_MERGEABLE (1 << 2)
	292	#define GOMP_TASK_FLAG_DEPEND (1 << 3)
	293	#define GOMP_TASK_FLAG_PRIORITY (1 << 4)
	294	#define GOMP_TASK_FLAG_UP (1 << 8)
	295	#define GOMP_TASK_FLAG_GRAINSIZE (1 << 9)
	296	#define GOMP_TASK_FLAG_IF (1 << 10)
	297	#define GOMP_TASK_FLAG_NOGROUP (1 << 11)
28567c40	298	#define GOMP_TASK_FLAG_REDUCTION (1 << 12)
a6d22fb2	299	#define GOMP_TASK_FLAG_DETACH (1 << 13)
3bc75533	300	#define GOMP_TASK_FLAG_STRICT (1 << 14)
d9a6bd32	301
e01d41e5	302	/* GOMP_target{_ext,update_ext,enter_exit_data} flags argument. */
d9a6bd32 JJ	303	#define GOMP_TARGET_FLAG_NOWAIT (1 << 0)
	304	#define GOMP_TARGET_FLAG_EXIT_DATA (1 << 1)
	305	/* Internal to libgomp. */
	306	#define GOMP_TARGET_FLAG_UPDATE (1U << 31)
	307
59d5960c TS	308
	309	/* OpenACC construct flags. */
	310
	311	/* Force host fallback execution. */
	312	#define GOACC_FLAG_HOST_FALLBACK (1 << 0)
3a359638 CLT	313	/* Execute on local device (i.e. host multicore CPU). */
3a359638 CLT	314	#define GOACC_FLAG_LOCAL_DEVICE (1 << 1)
59d5960c TS	315
	316	/* For legacy reasons, in the ABI, the GOACC_FLAGs are encoded as an inverted
	317	bitmask. */
	318	#define GOACC_FLAGS_MARSHAL_OP BIT_NOT_EXPR
	319	#define GOACC_FLAGS_UNMARSHAL(X) (~(X))
	320
	321
06fca33d CLT	322	/* Versions of libgomp and device-specific plugins. GOMP_VERSION
	323	should be incremented whenever an ABI-incompatible change is introduced
	324	to the plugin interface defined in libgomp/libgomp.h. */
a49c7d31	325	#define GOMP_VERSION 3
3e32ee19	326	#define GOMP_VERSION_NVIDIA_PTX 1
f6fff8a6	327	#define GOMP_VERSION_GCN 3
2a21ff19 NS	328
	329	#define GOMP_VERSION_PACK(LIB, DEV) (((LIB) << 16) \| (DEV))
	330	#define GOMP_VERSION_LIB(PACK) (((PACK) >> 16) & 0xffff)
	331	#define GOMP_VERSION_DEV(PACK) ((PACK) & 0xffff)
	332
a49c7d31 KCY	333	#define GOMP_VERSION_SUPPORTS_INDIRECT_FUNCS(VER) (GOMP_VERSION_LIB(VER) >= 3)
a49c7d31 KCY	334
3e32ee19 NS	335	#define GOMP_DIM_GANG 0
	336	#define GOMP_DIM_WORKER 1
	337	#define GOMP_DIM_VECTOR 2
	338	#define GOMP_DIM_MAX 3
	339	#define GOMP_DIM_MASK(X) (1u << (X))
	340
	341	/* Varadic launch arguments. End of list is marked by a zero. */
	342	#define GOMP_LAUNCH_DIM 1 /* Launch dimensions, op = mask */
	343	#define GOMP_LAUNCH_ASYNC 2 /* Async, op = cst val if not MAX */
	344	#define GOMP_LAUNCH_WAIT 3 /* Waits, op = num waits. */
	345	#define GOMP_LAUNCH_CODE_SHIFT 28
	346	#define GOMP_LAUNCH_DEVICE_SHIFT 16
	347	#define GOMP_LAUNCH_OP_SHIFT 0
	348	#define GOMP_LAUNCH_PACK(CODE,DEVICE,OP) \
	349	(((CODE) << GOMP_LAUNCH_CODE_SHIFT) \
	350	\| ((DEVICE) << GOMP_LAUNCH_DEVICE_SHIFT) \
	351	\| ((OP) << GOMP_LAUNCH_OP_SHIFT))
	352	#define GOMP_LAUNCH_CODE(X) (((X) >> GOMP_LAUNCH_CODE_SHIFT) & 0xf)
	353	#define GOMP_LAUNCH_DEVICE(X) (((X) >> GOMP_LAUNCH_DEVICE_SHIFT) & 0xfff)
	354	#define GOMP_LAUNCH_OP(X) (((X) >> GOMP_LAUNCH_OP_SHIFT) & 0xffff)
	355	#define GOMP_LAUNCH_OP_MAX 0xffff
	356
b2b40051 MJ	357	/* Bitmask to apply in order to find out the intended device of a target
	358	argument. */
	359	#define GOMP_TARGET_ARG_DEVICE_MASK ((1 << 7) - 1)
	360	/* The target argument is significant for all devices. */
	361	#define GOMP_TARGET_ARG_DEVICE_ALL 0
	362
	363	/* Flag set when the subsequent element in the device-specific argument
	364	values. */
	365	#define GOMP_TARGET_ARG_SUBSEQUENT_PARAM (1 << 7)
	366
	367	/* Bitmask to apply to a target argument to find out the value identifier. */
	368	#define GOMP_TARGET_ARG_ID_MASK (((1 << 8) - 1) << 8)
	369	/* Target argument index of NUM_TEAMS. */
	370	#define GOMP_TARGET_ARG_NUM_TEAMS (1 << 8)
	371	/* Target argument index of THREAD_LIMIT. */
	372	#define GOMP_TARGET_ARG_THREAD_LIMIT (2 << 8)
	373
	374	/* If the value is directly embeded in target argument, it should be a 16-bit
	375	at most and shifted by this many bits. */
	376	#define GOMP_TARGET_ARG_VALUE_SHIFT 16
	377
28567c40 JJ	378	/* Dependence types in omp_depend_t objects. */
	379	#define GOMP_DEPEND_IN 1
	380	#define GOMP_DEPEND_OUT 2
	381	#define GOMP_DEPEND_INOUT 3
	382	#define GOMP_DEPEND_MUTEXINOUTSET 4
2c16eb31	383	#define GOMP_DEPEND_INOUTSET 5
28567c40	384
2f0d819a	385	/* Flag values for OpenMP 'requires' directive features. */
683f1184 TB	386	#define GOMP_REQUIRES_UNIFIED_ADDRESS 0x10
	387	#define GOMP_REQUIRES_UNIFIED_SHARED_MEMORY 0x20
	388	#define GOMP_REQUIRES_REVERSE_OFFLOAD 0x80
	389	#define GOMP_REQUIRES_TARGET_USED 0x200
	390
b2b40051 MJ	391	/* HSA specific data structures. */
	392
	393	/* Identifiers of device-specific target arguments. */
	394	#define GOMP_TARGET_ARG_HSA_KERNEL_ATTRIBUTES (1 << 8)
	395
41dbbb37	396	#endif