/*************************************************************************/ /*!
@File
@Title          Common header containing type definitions for portability
@Copyright      Copyright (c) Imagination Technologies Ltd. All Rights Reserved
@Description    Contains variable and structure definitions. Any platform
                specific types should be defined in this file.
@License        Dual MIT/GPLv2

The contents of this file are subject to the MIT license as set out below.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

Alternatively, the contents of this file may be used under the terms of
the GNU General Public License Version 2 ("GPL") in which case the provisions
of GPL are applicable instead of those above.

If you wish to allow use of your version of this file only under the terms of
GPL, and not to allow others to use your version of this file under the terms
of the MIT license, indicate your decision by deleting the provisions above
and replace them with the notice and other provisions required by GPL as set
out in the file called "GPL-COPYING" included in this distribution. If you do
not delete the provisions above, a recipient may use your version of this file
under the terms of either the MIT license or GPL.

This License is also included in this distribution in the file called
"MIT-COPYING".

EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS
PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/ /**************************************************************************/

#ifndef IMG_DEFS_H
#define IMG_DEFS_H

#if defined(__linux__) && defined(__KERNEL__)
#include <linux/types.h>
#else
#include <stddef.h>
#endif
#if !(defined(__linux__) && defined(__KERNEL__))
#include <assert.h>
#endif

#include "img_types.h"

#if defined(NO_INLINE_FUNCS)
	#define	INLINE
	#define	FORCE_INLINE
#else
#if defined(__cplusplus) || defined(INTEGRITY_OS)
	#if	!defined(INLINE)
		#define INLINE				inline
	#endif
	#define	FORCE_INLINE			static inline
#else
#if	!defined(INLINE)
	#define	INLINE					__inline
#endif
#if (defined(UNDER_WDDM) || defined(WINDOWS_WDF)) && defined(_X86_)
	#define	FORCE_INLINE			__forceinline
#else
	#define	FORCE_INLINE			static __inline
#endif
#endif
#endif

/* True if the GCC version is at least the given version. False for older
 * versions of GCC, or other compilers.
 */
#define GCC_VERSION_AT_LEAST(major, minor) \
	(__GNUC__ > (major) || \
	(__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))

/* Use Clang's __has_extension and __has_builtin macros if available. */
#if defined(__has_extension)
#define has_clang_extension(e) __has_extension(e)
#else
#define has_clang_extension(e) 0
#endif

#if defined(__has_builtin)
#define has_clang_builtin(e) __has_builtin(e)
#else
#define has_clang_builtin(e) 0
#endif

/* Use this in any file, or use attributes under GCC - see below */
#ifndef PVR_UNREFERENCED_PARAMETER
#define	PVR_UNREFERENCED_PARAMETER(param) ((void)(param))
#endif

/* static_assert(condition, "message to print if it fails");
 *
 * Assert something at compile time. If the assertion fails, try to print
 * the message, otherwise do nothing. static_assert is available if:
 *
 * - It's already defined as a macro (e.g. by <assert.h> in C11)
 * - We're using MSVC which exposes static_assert unconditionally
 * - We're using a C++ compiler that supports C++11
 * - We're using GCC 4.6 and up in C mode (in which case it's available as
 *   _Static_assert)
 *
 * In all other cases, fall back to an equivalent that makes an invalid
 * declaration.
 */
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(5, 1, 0))
#if !defined(static_assert) && !defined(_MSC_VER) && \
		(!defined(__cplusplus) || __cplusplus < 201103L) || defined(__KLOCWORK__)
	/* static_assert isn't already available */
	#if !defined(__cplusplus) && (GCC_VERSION_AT_LEAST(4, 6) || \
								  (defined(__clang__) && has_clang_extension(c_static_assert)))
		#define static_assert _Static_assert
	#else
		#define static_assert(expr, message) \
			extern int static_assert_failed[(expr) ? 1 : -1] __attribute__((unused))
	#endif
#endif
#endif

/*
 * unreachable("explanation") can be used to indicate to the compiler that
 * some parts of the code can never be reached, like the default branch
 * of a switch that covers all real-world possibilities, even though there
 * are other ints that exist for instance.
 *
 * The message will be printed as an assert() when debugging.
 *
 * Note: there is no need to add a 'return' or any error handling after
 * calling unreachable(), as this call will never return.
 */
#if defined(__linux__) && defined(__KERNEL__)
/* Kernel has its own unreachable(), which is a simple infinite loop */
#elif GCC_VERSION_AT_LEAST(4, 5) || has_clang_builtin(__builtin_unreachable)
	#define unreachable(msg) \
		do { \
			assert(!(msg)); \
			__builtin_unreachable(); \
		} while (0)
#elif defined(_MSC_VER)
	#define unreachable(msg) \
		do { \
			assert(!(msg)); \
			__assume(0); \
		} while (0)
#else
	#define unreachable(msg) \
		do { \
			assert(!(msg)); \
			while (1); \
		} while (0)
#endif

/*
 * assume(x > 2 && x <= 7) works like an assert(), except it hints to the
 * compiler what it can assume to optimise the code, like a limited range
 * of parameter values.
 */
#if has_clang_builtin(__builtin_assume)
	#define assume(expr) \
		do { \
			assert(expr); \
			__builtin_assume(expr); \
		} while (0)
#elif defined(_MSC_VER)
	#define assume(expr) \
		do { \
			assert(expr); \
			__assume(expr); \
		} while (0)
#elif defined(__linux__) && defined(__KERNEL__)
	#define assume(expr) ((void)(expr))
#elif GCC_VERSION_AT_LEAST(4, 5) || has_clang_builtin(__builtin_unreachable)
	#define assume(expr) \
		do { \
			if (unlikely(!(expr))) \
				unreachable("Assumption isn't true: " # expr); \
		} while (0)
#else
	#define assume(expr) assert(expr)
#endif

/*! Macro to calculate the n-byte aligned value from that supplied rounding up.
 * n must be a power of two.
 *
 * Both arguments should be of a type with the same size otherwise the macro may
 * cut off digits, e.g. imagine a 64 bit address in _x and a 32 bit value in _n.
 */
#define PVR_ALIGN(_x, _n)	(((_x)+((_n)-1U)) & ~((_n)-1U))

#if defined(_WIN32)

#if defined(WINDOWS_WDF)

	/*
	 * For WINDOWS_WDF drivers we don't want these defines to overwrite calling conventions propagated through the build system.
	 * This 'empty' choice helps to resolve all the calling conv issues.
	 *
	 */
	#define IMG_CALLCONV
	#define C_CALLCONV

	#define IMG_INTERNAL
	#define IMG_RESTRICT __restrict

	/*
	 * The proper way of dll linking under MS compilers is made of two things:
	 * - decorate implementation with __declspec(dllexport)
	 *   this decoration helps compiler with making the so called
	 *   'export library'
	 * - decorate forward-declaration (in a source dependent on a dll) with
	 *   __declspec(dllimport), this decoration helps the compiler to make
	 *   faster and smaller code in terms of calling dll-imported functions
	 *
	 * Usually these decorations are performed by having a single macro define
	 * making that expands to a proper __declspec() depending on the
	 * translation unit, dllexport inside the dll source and dllimport outside
	 * the dll source. Having IMG_EXPORT and IMG_IMPORT resolving to the same
	 * __declspec() makes no sense, but at least works.
	 */
	#define IMG_IMPORT __declspec(dllexport)
	#define IMG_EXPORT __declspec(dllexport)

#else

	#define IMG_CALLCONV __stdcall
	#define IMG_INTERNAL
	#define	IMG_EXPORT	__declspec(dllexport)
	#define IMG_RESTRICT __restrict
	#define C_CALLCONV	__cdecl

	/*
	 * IMG_IMPORT is defined as IMG_EXPORT so that headers and implementations
	 * match. Some compilers require the header to be declared IMPORT, while
	 * the implementation is declared EXPORT.
	 */
	#define	IMG_IMPORT	IMG_EXPORT

#endif

#if defined(UNDER_WDDM)
	#ifndef	_INC_STDLIB
		#if defined(__mips)
			/* do nothing */
		#elif defined(UNDER_MSBUILD)
			/* do nothing */
		#else
			_CRTIMP void __cdecl abort(void);
		#endif
	#endif
#endif /* UNDER_WDDM */
#else
	#if (defined(__linux__) || defined(__QNXNTO__)) && defined(__KERNEL__)
		#define IMG_INTERNAL
		#define IMG_EXPORT
		#define IMG_CALLCONV
	#elif defined(__linux__) || defined(__METAG) || defined(__mips) || defined(__QNXNTO__) || defined(__riscv)
		#define IMG_CALLCONV
		#define C_CALLCONV

		#if defined(__METAG)
			#define IMG_INTERNAL
		#else
			#define IMG_INTERNAL    __attribute__((visibility("hidden")))
		#endif

		#define IMG_EXPORT      __attribute__((visibility("default")))
		#define IMG_RESTRICT    __restrict__
	#elif defined(INTEGRITY_OS)
		#define IMG_CALLCONV
		#define IMG_INTERNAL
		#define IMG_EXPORT
		#define IMG_RESTRICT
		#define C_CALLCONV
		#define __cdecl

		#ifndef USE_CODE
			#define IMG_ABORT() printf("IMG_ABORT was called.\n")
		#endif
	#else
		#error("define an OS")
	#endif

#endif

/* Use default definition if not overridden */
#ifndef IMG_ABORT
	#if defined(EXIT_ON_ABORT)
		#define IMG_ABORT()	exit(1)
	#else
		#define IMG_ABORT()	abort()
	#endif
#endif

/* The best way to suppress unused parameter warnings using GCC is to use a
 * variable attribute. Place the __maybe_unused between the type and name of an
 * unused parameter in a function parameter list e.g. 'int __maybe_unused var'.
 * This should only be used in GCC build environments, for example, in files
 * that compile only on Linux.
 * Other files should use PVR_UNREFERENCED_PARAMETER
 */

/* Kernel macros for compiler attributes */
/* Note: param positions start at 1 */
#if defined(__linux__) && defined(__KERNEL__)
	#include <linux/compiler.h>

	#if !defined(__fallthrough)
		#if defined(__GNUC__) && GCC_VERSION_AT_LEAST(7, 0)
			#define __fallthrough __attribute__((__fallthrough__))
		#else
			#define __fallthrough
		#endif
	#endif
#elif defined(__GNUC__) || defined(HAS_GNUC_ATTRIBUTES)
	#define __must_check       __attribute__((warn_unused_result))
	#define __maybe_unused     __attribute__((unused))
	#define __malloc           __attribute__((malloc))

	/* Bionic's <sys/cdefs.h> might have defined these already */
	/* See https://android.googlesource.com/platform/bionic.git/+/master/libc/include/sys/cdefs.h */
	#if !defined(__packed)
		#define __packed           __attribute__((packed))
	#endif
	#if !defined(__aligned)
		#define __aligned(n)       __attribute__((aligned(n)))
	#endif
	#if !defined(__noreturn)
		#define __noreturn         __attribute__((noreturn))
	#endif

	/* That one compiler that supports attributes but doesn't support
	 * the printf attribute... */
	#if defined(__GNUC__)
		#define __printf(fmt, va)  __attribute__((format(printf, (fmt), (va))))
	#else
		#define __printf(fmt, va)
	#endif /* defined(__GNUC__) */

	#if defined(__cplusplus) && (__cplusplus >= 201703L)
		#define __fallthrough [[fallthrough]]
	#elif defined(__GNUC__) && GCC_VERSION_AT_LEAST(7, 0)
		#define __fallthrough __attribute__((__fallthrough__))
	#else
		#define __fallthrough
	#endif

	#define __user
	#define __force
	#define __iomem
#else
	/* Silently ignore those attributes */
	#define __printf(fmt, va)
	#define __packed
	#define __aligned(n)
	#define __must_check
	#define __maybe_unused
	#define __malloc

	#if defined(_MSC_VER) || defined(CC_ARM)
		#define __noreturn __declspec(noreturn)
	#else
		#define __noreturn
	#endif

	/* This may already been defined, e.g. by SAL (Source Annotation Language) */
	#if !defined(__fallthrough)
		#define __fallthrough
	#endif

	#define __user
	#define __force
	#define __iomem
#endif


/* Other attributes, following the same style */
#if defined(__GNUC__) || defined(HAS_GNUC_ATTRIBUTES)
	#define __const_function      __attribute__((const))
#else
	#define __const_function
#endif


/* GCC builtins */
#if defined(__linux__) && defined(__KERNEL__)
	#include <linux/compiler.h>
#elif defined(__GNUC__) || defined(INTEGRITY_OS)

/* Klocwork does not support __builtin_expect, which makes the actual condition
 * expressions hidden during analysis, affecting it negatively. */
#if !defined(__KLOCWORK__) && !defined(INTEGRITY_OS) && !defined(DEBUG)
	#define likely(x)   __builtin_expect(!!(x), 1)
	#define unlikely(x) __builtin_expect(!!(x), 0)
#endif

	/* Compiler memory barrier to prevent reordering */
	#define barrier() __asm__ __volatile__("": : :"memory")
#else
	#define barrier() static_assert(0, "barrier() isn't supported by your compiler");
#endif

/* That one OS that defines one but not the other... */
#ifndef likely
	#define likely(x)   (x)
#endif
#ifndef unlikely
	#define unlikely(x) (x)
#endif

#if (LINUX_VERSION_CODE <= KERNEL_VERSION(5, 1, 0))
/* These two macros are also provided by the kernel */
#ifndef BIT
#define BIT(b) (1UL << (b))
#endif

#ifndef BIT_ULL
#define BIT_ULL(b) (1ULL << (b))
#endif
#endif

#define BIT_SET(f, b)     BITMASK_SET((f),    BIT(b))
#define BIT_UNSET(f, b)   BITMASK_UNSET((f),  BIT(b))
#define BIT_TOGGLE(f, b)  BITMASK_TOGGLE((f), BIT(b))
#define BIT_ISSET(f, b)   BITMASK_HAS((f),    BIT(b))

#define BITMASK_SET(f, m)     do { ((f) |= (m)); } while (false)
#define BITMASK_UNSET(f, m)   do { ((f) &= ~(m)); } while (false)
#define BITMASK_TOGGLE(f, m)  do { ((f) ^= (m)); } while (false)
#define BITMASK_HAS(f, m)     (((f) & (m)) == (m)) /* the bits from the mask are all set */
#define BITMASK_ANY(f, m)     (((f) & (m)) != 0U)  /* any bit from the mask is set */

#ifndef MAX
#define MAX(a ,b)	(((a) > (b)) ? (a) : (b))
#endif

#ifndef MIN
#define MIN(a, b)	(((a) < (b)) ? (a) : (b))
#endif

#ifndef CLAMP
#define CLAMP(min, max, n)  ((n) < (min) ? (min) : ((n) > (max) ? (max) : (n)))
#endif

#define SWAP(X, Y) (X) ^= (Y); (Y) ^= (X); (X) ^= (Y);


#if defined(__linux__) && defined(__KERNEL__)
	#include <linux/kernel.h>
	#include <linux/bug.h>
#endif

/* Get a structure's address from the address of a member */
#define IMG_CONTAINER_OF(ptr, type, member) \
	(type *) ((uintptr_t) (ptr) - offsetof(type, member))

/* Get a new pointer with an offset (in bytes) from a base address, useful
 * when traversing byte buffers and accessing data in buffers through struct
 * pointers.
 * Note, this macro is not equivalent to or replacing offsetof() */
#define IMG_OFFSET_ADDR(addr, offset_in_bytes) \
	(void*)&(((IMG_UINT8*)(void*)(addr))[offset_in_bytes])

/* Get a new pointer with an offset (in dwords) from a base address, useful
 * when traversing byte buffers and accessing data in buffers through struct
 * pointers.
 * Note, this macro is not equivalent to or replacing offsetof() */
#define IMG_OFFSET_ADDR_DW(addr, offset_in_dwords) \
	(void*)(((IMG_UINT32*)(void*)(addr)) + (offset_in_dwords))

#if (LINUX_VERSION_CODE <= KERNEL_VERSION(5, 1, 0))
/* The number of elements in a fixed-sized array */
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(ARR) (sizeof(ARR) / sizeof((ARR)[0]))
#endif
#endif

/* To guarantee that __func__ can be used, define it as a macro here if it
   isn't already provided by the compiler. */
#if defined(_MSC_VER) || (defined(__cplusplus) && __cplusplus < 201103L)
#define __func__ __FUNCTION__
#endif

#if defined(__cplusplus)
/* C++ Specific:
 * Disallow use of copy and assignment operator within a class.
 * Should be placed under private. */
#define IMG_DISALLOW_COPY_AND_ASSIGN(C) \
	C(const C&); \
	void operator=(const C&)
#endif

#if defined(SUPPORT_PVR_VALGRIND) && !defined(__METAG) && !defined(__mips) && !defined(__riscv)
	#include "/usr/include/valgrind/memcheck.h"

	#define VG_MARK_INITIALIZED(pvData,ui32Size) VALGRIND_MAKE_MEM_DEFINED(pvData,ui32Size)
	#define VG_MARK_NOACCESS(pvData,ui32Size) VALGRIND_MAKE_MEM_NOACCESS(pvData,ui32Size)
	#define VG_MARK_ACCESS(pvData,ui32Size) VALGRIND_MAKE_MEM_UNDEFINED(pvData,ui32Size)
#else
	#if defined(_MSC_VER)
	#	define PVR_MSC_SUPPRESS_4127 __pragma(warning(suppress:4127))
	#else
	#	define PVR_MSC_SUPPRESS_4127
	#endif

	#define VG_MARK_INITIALIZED(pvData,ui32Size) PVR_MSC_SUPPRESS_4127 do { } while (0)
	#define VG_MARK_NOACCESS(pvData,ui32Size) PVR_MSC_SUPPRESS_4127 do { } while (0)
	#define VG_MARK_ACCESS(pvData,ui32Size) PVR_MSC_SUPPRESS_4127 do { } while (0)
#endif

#define IMG_STRINGIFY_IMPL(x) # x
#define IMG_STRINGIFY(x) IMG_STRINGIFY_IMPL(x)

#if defined(INTEGRITY_OS)
	/* Definitions not present in INTEGRITY. */
	#define PATH_MAX	200
#endif

#if defined(__clang__) || defined(__GNUC__)
	/* __SIZEOF_POINTER__ is defined already by these compilers */
#elif defined(INTEGRITY_OS)
	#if defined(__Ptr_Is_64)
		#define __SIZEOF_POINTER__ 8
	#else
		#define __SIZEOF_POINTER__ 4
	#endif
#elif defined(_WIN32)
	#define __SIZEOF_POINTER__ sizeof(char *)
#else
	#warning Unknown OS - using default method to determine whether CPU arch is 64-bit.
	#define __SIZEOF_POINTER__ sizeof(char *)
#endif

/* RDI8567: gcc/clang/llvm load/store optimisations may cause issues with
 * uncached device memory allocations. Some pointers are made 'volatile'
 * to prevent those optimisations being applied to writes through those
 * pointers.
 */
#if (GCC_VERSION_AT_LEAST(7, 0) || defined(__clang__)) && (defined(__arm64__) || defined(__aarch64__))
#define NOLDSTOPT volatile
/* after applying 'volatile' to a pointer, we may need to cast it to 'void *'
 * to keep it compatible with its existing uses.
 */
#define NOLDSTOPT_VOID (void *)

#define NOLDSTOPT_REQUIRED 1
#else
#define NOLDSTOPT
#define NOLDSTOPT_VOID
#endif

#endif /* IMG_DEFS_H */
/*****************************************************************************
 End of file (img_defs.h)
*****************************************************************************/
