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

/* Communication between GCC and libgomp.

   Copyright (C) 2014-2019 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_4		(1 << 6)
#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)
/* Flag to force a specific behavior (or else, trigger a run-time error).  */
#define GOMP_MAP_FLAG_FORCE		(1 << 7)

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.  */
    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),
    /* 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),
    /* 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),
    /* 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),
    /* 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),
    /* 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),

    /* 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)
  };

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

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

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

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

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

#define GOMP_MAP_ALWAYS_P(X) \
  (GOMP_MAP_ALWAYS_TO_P (X) || ((X) == GOMP_MAP_ALWAYS_FROM))


/* 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
#define GOMP_DEVICE_HSA			7
#define GOMP_DEVICE_GCN			8

#define GOMP_DEVICE_ICV			-1
#define GOMP_DEVICE_HOST_FALLBACK	-2

/* Device property codes.  Keep in sync with
   libgomp/{openacc.h,openacc.f90}:acc_device_property_t */
/* Start from 1 to catch uninitialized use.  */
enum gomp_device_property
  {
   GOMP_DEVICE_PROPERTY_MEMORY =	1,
   GOMP_DEVICE_PROPERTY_FREE_MEMORY = 	2,
   GOMP_DEVICE_PROPERTY_NAME =		0x10001,
   GOMP_DEVICE_PROPERTY_VENDOR =	0x10002,
   GOMP_DEVICE_PROPERTY_DRIVER =	0x10003
  };

/* Internal property mask to tell numeric and string values apart.  */
#define GOMP_DEVICE_PROPERTY_STRING_MASK	0x10000

/* 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)

/* 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)

/* 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	1
#define GOMP_VERSION_NVIDIA_PTX 1
#define GOMP_VERSION_INTEL_MIC 0
#define GOMP_VERSION_HSA 0
#define GOMP_VERSION_GCN 1

#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_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

/* 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
a5544970	3	Copyright (C) 2014-2019 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)
8e7e71ff	43	#define GOMP_MAP_FLAG_SPECIAL_4 (1 << 6)
41dbbb37 TS	44	#define GOMP_MAP_FLAG_SPECIAL (GOMP_MAP_FLAG_SPECIAL_1 \
41dbbb37 TS	45	\| GOMP_MAP_FLAG_SPECIAL_0)
8e7e71ff JB	46	#define GOMP_MAP_DEEP_COPY (GOMP_MAP_FLAG_SPECIAL_4 \
8e7e71ff JB	47	\| GOMP_MAP_FLAG_SPECIAL_2)
41dbbb37 TS	48	/* Flag to force a specific behavior (or else, trigger a run-time error). */
	49	#define GOMP_MAP_FLAG_FORCE (1 << 7)
	50
	51	enum gomp_map_kind
	52	{
	53	/* If not already present, allocate. */
	54	GOMP_MAP_ALLOC = 0,
	55	/* ..., and copy to device. */
	56	GOMP_MAP_TO = (GOMP_MAP_ALLOC \| GOMP_MAP_FLAG_TO),
	57	/* ..., and copy from device. */
	58	GOMP_MAP_FROM = (GOMP_MAP_ALLOC \| GOMP_MAP_FLAG_FROM),
	59	/* ..., and copy to and from device. */
	60	GOMP_MAP_TOFROM = (GOMP_MAP_TO \| GOMP_MAP_FROM),
	61	/* The following kind is an internal only map kind, used for pointer based
	62	array sections. OMP_CLAUSE_SIZE for these is not the pointer size,
	63	which is implicitly POINTER_SIZE_UNITS, but the bias. */
	64	GOMP_MAP_POINTER = (GOMP_MAP_FLAG_SPECIAL_0 \| 0),
	65	/* Also internal, behaves like GOMP_MAP_TO, but additionally any
	66	GOMP_MAP_POINTER records consecutive after it which have addresses
	67	falling into that range will not be ignored if GOMP_MAP_TO_PSET wasn't
	68	mapped already. */
	69	GOMP_MAP_TO_PSET = (GOMP_MAP_FLAG_SPECIAL_0 \| 1),
	70	/* Must already be present. */
	71	GOMP_MAP_FORCE_PRESENT = (GOMP_MAP_FLAG_SPECIAL_0 \| 2),
	72	/* Deallocate a mapping, without copying from device. */
91106e84	73	GOMP_MAP_DELETE = (GOMP_MAP_FLAG_SPECIAL_0 \| 3),
41dbbb37 TS	74	/* Is a device pointer. OMP_CLAUSE_SIZE for these is unused; is implicitly
	75	POINTER_SIZE_UNITS. */
	76	GOMP_MAP_FORCE_DEVICEPTR = (GOMP_MAP_FLAG_SPECIAL_1 \| 0),
6e232ba4 JN	77	/* OpenACC device_resident. */
	78	GOMP_MAP_DEVICE_RESIDENT = (GOMP_MAP_FLAG_SPECIAL_1 \| 1),
	79	/* OpenACC link. */
	80	GOMP_MAP_LINK = (GOMP_MAP_FLAG_SPECIAL_1 \| 2),
a6163563 JB	81	/* Use device data if present, fall back to host address otherwise. */
a6163563 JB	82	GOMP_MAP_IF_PRESENT = (GOMP_MAP_FLAG_SPECIAL_1 \| 3),
cbdce905	83	/* Do not map, copy bits for firstprivate instead. */
d9a6bd32 JJ	84	GOMP_MAP_FIRSTPRIVATE = (GOMP_MAP_FLAG_SPECIAL \| 0),
	85	/* Similarly, but store the value in the pointer rather than
	86	pointed by the pointer. */
	87	GOMP_MAP_FIRSTPRIVATE_INT = (GOMP_MAP_FLAG_SPECIAL \| 1),
	88	/* Pointer translate host address into device address and copy that
	89	back to host. */
	90	GOMP_MAP_USE_DEVICE_PTR = (GOMP_MAP_FLAG_SPECIAL \| 2),
	91	/* Allocate a zero length array section. Prefer next non-zero length
	92	mapping over previous non-zero length mapping over zero length mapping
	93	at the address. If not already mapped, do nothing (and pointer translate
	94	to NULL). */
	95	GOMP_MAP_ZERO_LEN_ARRAY_SECTION = (GOMP_MAP_FLAG_SPECIAL \| 3),
41dbbb37 TS	96	/* Allocate. */
	97	GOMP_MAP_FORCE_ALLOC = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_ALLOC),
	98	/* ..., and copy to device. */
	99	GOMP_MAP_FORCE_TO = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_TO),
	100	/* ..., and copy from device. */
	101	GOMP_MAP_FORCE_FROM = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_FROM),
	102	/* ..., and copy to and from device. */
d9a6bd32 JJ	103	GOMP_MAP_FORCE_TOFROM = (GOMP_MAP_FLAG_FORCE \| GOMP_MAP_TOFROM),
	104	/* If not already present, allocate. And unconditionally copy to
	105	device. */
e01d41e5	106	GOMP_MAP_ALWAYS_TO = (GOMP_MAP_FLAG_SPECIAL_2 \| GOMP_MAP_TO),
d9a6bd32 JJ	107	/* If not already present, allocate. And unconditionally copy from
d9a6bd32 JJ	108	device. */
e01d41e5 JJ	109	GOMP_MAP_ALWAYS_FROM = (GOMP_MAP_FLAG_SPECIAL_2
e01d41e5 JJ	110	\| GOMP_MAP_FROM),
d9a6bd32 JJ	111	/* If not already present, allocate. And unconditionally copy to and from
d9a6bd32 JJ	112	device. */
e01d41e5 JJ	113	GOMP_MAP_ALWAYS_TOFROM = (GOMP_MAP_FLAG_SPECIAL_2
e01d41e5 JJ	114	\| GOMP_MAP_TOFROM),
d9a6bd32 JJ	115	/* Map a sparse struct; the address is the base of the structure, alignment
	116	it's required alignment, and size is the number of adjacent entries
	117	that belong to the struct. The adjacent entries should be sorted by
	118	increasing address, so it is easy to determine lowest needed address
	119	(address of the first adjacent entry) and highest needed address
	120	(address of the last adjacent entry plus its size). */
e01d41e5	121	GOMP_MAP_STRUCT = (GOMP_MAP_FLAG_SPECIAL_2
d9a6bd32	122	\| GOMP_MAP_FLAG_SPECIAL \| 0),
e01d41e5 JJ	123	/* On a location of a pointer/reference that is assumed to be already mapped
	124	earlier, store the translated address of the preceeding mapping.
	125	No refcount is bumped by this, and the store is done unconditionally. */
	126	GOMP_MAP_ALWAYS_POINTER = (GOMP_MAP_FLAG_SPECIAL_2
	127	\| GOMP_MAP_FLAG_SPECIAL \| 1),
d9a6bd32 JJ	128	/* Forced deallocation of zero length array section. */
d9a6bd32 JJ	129	GOMP_MAP_DELETE_ZERO_LEN_ARRAY_SECTION
e01d41e5	130	= (GOMP_MAP_FLAG_SPECIAL_2
d9a6bd32	131	\| GOMP_MAP_FLAG_SPECIAL \| 3),
d9a6bd32	132	/* Decrement usage count and deallocate if zero. */
e01d41e5	133	GOMP_MAP_RELEASE = (GOMP_MAP_FLAG_SPECIAL_2
91106e84	134	\| GOMP_MAP_DELETE),
8e7e71ff JB	135	/* In OpenACC, attach a pointer to a mapped struct field. */
	136	GOMP_MAP_ATTACH = (GOMP_MAP_DEEP_COPY \| 0),
	137	/* In OpenACC, detach a pointer to a mapped struct field. */
	138	GOMP_MAP_DETACH = (GOMP_MAP_DEEP_COPY \| 1),
	139	/* In OpenACC, detach a pointer to a mapped struct field. */
	140	GOMP_MAP_FORCE_DETACH = (GOMP_MAP_DEEP_COPY
	141	\| GOMP_MAP_FLAG_FORCE \| 1),
d9a6bd32 JJ	142
	143	/* Internal to GCC, not used in libgomp. */
	144	/* Do not map, but pointer assign a pointer instead. */
e01d41e5 JJ	145	GOMP_MAP_FIRSTPRIVATE_POINTER = (GOMP_MAP_LAST \| 1),
e01d41e5 JJ	146	/* Do not map, but pointer assign a reference instead. */
4fd872bc JB	147	GOMP_MAP_FIRSTPRIVATE_REFERENCE = (GOMP_MAP_LAST \| 2),
	148	/* An attach or detach operation. Rewritten to the appropriate type during
	149	gimplification, depending on directive (i.e. "enter data" or
	150	parallel/kernels region vs. "exit data"). */
	151	GOMP_MAP_ATTACH_DETACH = (GOMP_MAP_LAST \| 3)
41dbbb37 TS	152	};
	153
	154	#define GOMP_MAP_COPY_TO_P(X) \
	155	(!((X) & GOMP_MAP_FLAG_SPECIAL) \
	156	&& ((X) & GOMP_MAP_FLAG_TO))
	157
	158	#define GOMP_MAP_COPY_FROM_P(X) \
	159	(!((X) & GOMP_MAP_FLAG_SPECIAL) \
	160	&& ((X) & GOMP_MAP_FLAG_FROM))
	161
	162	#define GOMP_MAP_POINTER_P(X) \
	163	((X) == GOMP_MAP_POINTER)
	164
d9a6bd32 JJ	165	#define GOMP_MAP_ALWAYS_TO_P(X) \
	166	(((X) == GOMP_MAP_ALWAYS_TO) \|\| ((X) == GOMP_MAP_ALWAYS_TOFROM))
	167
	168	#define GOMP_MAP_ALWAYS_FROM_P(X) \
	169	(((X) == GOMP_MAP_ALWAYS_FROM) \|\| ((X) == GOMP_MAP_ALWAYS_TOFROM))
	170
e01d41e5 JJ	171	#define GOMP_MAP_ALWAYS_P(X) \
	172	(GOMP_MAP_ALWAYS_TO_P (X) \|\| ((X) == GOMP_MAP_ALWAYS_FROM))
	173
41dbbb37 TS	174
	175	/* Asynchronous behavior. Keep in sync with
	176	libgomp/{openacc.h,openacc.f90,openacc_lib.h}:acc_async_t. */
	177
	178	#define GOMP_ASYNC_NOVAL -1
	179	#define GOMP_ASYNC_SYNC -2
	180
	181
	182	/* Device codes. Keep in sync with
	183	libgomp/{openacc.h,openacc.f90,openacc_lib.h}:acc_device_t as well as
b97e78b7	184	libgomp/libgomp-plugin.h. */
41dbbb37 TS	185	#define GOMP_DEVICE_NONE 0
	186	#define GOMP_DEVICE_DEFAULT 1
	187	#define GOMP_DEVICE_HOST 2
b97e78b7	188	/* #define GOMP_DEVICE_HOST_NONSHM 3 removed. */
41dbbb37 TS	189	#define GOMP_DEVICE_NOT_HOST 4
	190	#define GOMP_DEVICE_NVIDIA_PTX 5
	191	#define GOMP_DEVICE_INTEL_MIC 6
b2b40051	192	#define GOMP_DEVICE_HSA 7
fa499995	193	#define GOMP_DEVICE_GCN 8
41dbbb37 TS	194
	195	#define GOMP_DEVICE_ICV -1
	196	#define GOMP_DEVICE_HOST_FALLBACK -2
	197
6c84c8bf MR	198	/* Device property codes. Keep in sync with
	199	libgomp/{openacc.h,openacc.f90}:acc_device_property_t */
	200	/* Start from 1 to catch uninitialized use. */
	201	enum gomp_device_property
	202	{
	203	GOMP_DEVICE_PROPERTY_MEMORY = 1,
	204	GOMP_DEVICE_PROPERTY_FREE_MEMORY = 2,
	205	GOMP_DEVICE_PROPERTY_NAME = 0x10001,
	206	GOMP_DEVICE_PROPERTY_VENDOR = 0x10002,
	207	GOMP_DEVICE_PROPERTY_DRIVER = 0x10003
	208	};
	209
	210	/* Internal property mask to tell numeric and string values apart. */
	211	#define GOMP_DEVICE_PROPERTY_STRING_MASK 0x10000
	212
d9a6bd32 JJ	213	/* GOMP_task/GOMP_taskloop* flags argument. */
	214	#define GOMP_TASK_FLAG_UNTIED (1 << 0)
	215	#define GOMP_TASK_FLAG_FINAL (1 << 1)
	216	#define GOMP_TASK_FLAG_MERGEABLE (1 << 2)
	217	#define GOMP_TASK_FLAG_DEPEND (1 << 3)
	218	#define GOMP_TASK_FLAG_PRIORITY (1 << 4)
	219	#define GOMP_TASK_FLAG_UP (1 << 8)
	220	#define GOMP_TASK_FLAG_GRAINSIZE (1 << 9)
	221	#define GOMP_TASK_FLAG_IF (1 << 10)
	222	#define GOMP_TASK_FLAG_NOGROUP (1 << 11)
28567c40	223	#define GOMP_TASK_FLAG_REDUCTION (1 << 12)
d9a6bd32	224
e01d41e5	225	/* GOMP_target{_ext,update_ext,enter_exit_data} flags argument. */
d9a6bd32 JJ	226	#define GOMP_TARGET_FLAG_NOWAIT (1 << 0)
	227	#define GOMP_TARGET_FLAG_EXIT_DATA (1 << 1)
	228	/* Internal to libgomp. */
	229	#define GOMP_TARGET_FLAG_UPDATE (1U << 31)
	230
59d5960c TS	231
	232	/* OpenACC construct flags. */
	233
	234	/* Force host fallback execution. */
	235	#define GOACC_FLAG_HOST_FALLBACK (1 << 0)
	236
	237	/* For legacy reasons, in the ABI, the GOACC_FLAGs are encoded as an inverted
	238	bitmask. */
	239	#define GOACC_FLAGS_MARSHAL_OP BIT_NOT_EXPR
	240	#define GOACC_FLAGS_UNMARSHAL(X) (~(X))
	241
	242
06fca33d CLT	243	/* Versions of libgomp and device-specific plugins. GOMP_VERSION
	244	should be incremented whenever an ABI-incompatible change is introduced
	245	to the plugin interface defined in libgomp/libgomp.h. */
	246	#define GOMP_VERSION 1
3e32ee19	247	#define GOMP_VERSION_NVIDIA_PTX 1
2a21ff19	248	#define GOMP_VERSION_INTEL_MIC 0
b2b40051	249	#define GOMP_VERSION_HSA 0
fa499995	250	#define GOMP_VERSION_GCN 1
2a21ff19 NS	251
	252	#define GOMP_VERSION_PACK(LIB, DEV) (((LIB) << 16) \| (DEV))
	253	#define GOMP_VERSION_LIB(PACK) (((PACK) >> 16) & 0xffff)
	254	#define GOMP_VERSION_DEV(PACK) ((PACK) & 0xffff)
	255
3e32ee19 NS	256	#define GOMP_DIM_GANG 0
	257	#define GOMP_DIM_WORKER 1
	258	#define GOMP_DIM_VECTOR 2
	259	#define GOMP_DIM_MAX 3
	260	#define GOMP_DIM_MASK(X) (1u << (X))
	261
	262	/* Varadic launch arguments. End of list is marked by a zero. */
	263	#define GOMP_LAUNCH_DIM 1 /* Launch dimensions, op = mask */
	264	#define GOMP_LAUNCH_ASYNC 2 /* Async, op = cst val if not MAX */
	265	#define GOMP_LAUNCH_WAIT 3 /* Waits, op = num waits. */
	266	#define GOMP_LAUNCH_CODE_SHIFT 28
	267	#define GOMP_LAUNCH_DEVICE_SHIFT 16
	268	#define GOMP_LAUNCH_OP_SHIFT 0
	269	#define GOMP_LAUNCH_PACK(CODE,DEVICE,OP) \
	270	(((CODE) << GOMP_LAUNCH_CODE_SHIFT) \
	271	\| ((DEVICE) << GOMP_LAUNCH_DEVICE_SHIFT) \
	272	\| ((OP) << GOMP_LAUNCH_OP_SHIFT))
	273	#define GOMP_LAUNCH_CODE(X) (((X) >> GOMP_LAUNCH_CODE_SHIFT) & 0xf)
	274	#define GOMP_LAUNCH_DEVICE(X) (((X) >> GOMP_LAUNCH_DEVICE_SHIFT) & 0xfff)
	275	#define GOMP_LAUNCH_OP(X) (((X) >> GOMP_LAUNCH_OP_SHIFT) & 0xffff)
	276	#define GOMP_LAUNCH_OP_MAX 0xffff
	277
b2b40051 MJ	278	/* Bitmask to apply in order to find out the intended device of a target
	279	argument. */
	280	#define GOMP_TARGET_ARG_DEVICE_MASK ((1 << 7) - 1)
	281	/* The target argument is significant for all devices. */
	282	#define GOMP_TARGET_ARG_DEVICE_ALL 0
	283
	284	/* Flag set when the subsequent element in the device-specific argument
	285	values. */
	286	#define GOMP_TARGET_ARG_SUBSEQUENT_PARAM (1 << 7)
	287
	288	/* Bitmask to apply to a target argument to find out the value identifier. */
	289	#define GOMP_TARGET_ARG_ID_MASK (((1 << 8) - 1) << 8)
	290	/* Target argument index of NUM_TEAMS. */
	291	#define GOMP_TARGET_ARG_NUM_TEAMS (1 << 8)
	292	/* Target argument index of THREAD_LIMIT. */
	293	#define GOMP_TARGET_ARG_THREAD_LIMIT (2 << 8)
	294
	295	/* If the value is directly embeded in target argument, it should be a 16-bit
	296	at most and shifted by this many bits. */
	297	#define GOMP_TARGET_ARG_VALUE_SHIFT 16
	298
28567c40 JJ	299	/* Dependence types in omp_depend_t objects. */
	300	#define GOMP_DEPEND_IN 1
	301	#define GOMP_DEPEND_OUT 2
	302	#define GOMP_DEPEND_INOUT 3
	303	#define GOMP_DEPEND_MUTEXINOUTSET 4
	304
b2b40051 MJ	305	/* HSA specific data structures. */
	306
	307	/* Identifiers of device-specific target arguments. */
	308	#define GOMP_TARGET_ARG_HSA_KERNEL_ATTRIBUTES (1 << 8)
	309
41dbbb37	310	#endif