nvcommon.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2006-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA Corporation and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA Corporation is strictly prohibited.
 */
 
#ifndef INCLUDED_NVCOMMON_H
#define INCLUDED_NVCOMMON_H
#if ((defined(__QNX__) || defined(__linux__)) && defined(NV_IS_SAFETY) && (NV_IS_SAFETY == 1))
#include "nvcommon_tegra_safety.h"
#else
 
// Pull in some headers that are mirrored from desktop.
#include "nvtypes.h"
 
#include <stddef.h>
#if defined(__hos__) || (defined(__linux__) && !defined(__KERNEL__)) || defined(__arm) || defined(__APPLE__) || defined(__QNX__) || defined(__INTEGRITY) || defined(NV_HYPERVISOR)
#include <stdint.h>
#endif
 
// Rest of this file is mobile-only definitions, and appending to them
// is discouraged since it prevents header portability between mobile
// and desktop.
#define NV_FORCE_INLINE NV_FORCEINLINE
#define NV_ALIGN NV_ALIGN_BYTES
 
#if (NVCPU_IS_X86 && NVOS_IS_WINDOWS)
#   define NVOS_IS_WINDOWS_X86 1
#else
#   define NVOS_IS_WINDOWS_X86 0
#endif
 
#if defined(__APPLE__)
#  define NVOS_IS_DARWIN 1
#  define NVOS_IS_UNIX 1
#endif
 
#define NVOS_IS_LINUX_KERNEL 0
 
#define NV_MIN_F32  (1.1754944e-38f)
#define NV_MAX_F32  (3.4028234e+38f)
 
#if defined(__GNUC__)
#define NV_ALIGN_POINTER_NAME(f) f##Align
#define NV_ALIGN_POINTER(t, f)                  \
    union {                                     \
        t f;                                    \
        NvU64 NV_ALIGN_POINTER_NAME(f);         \
    }
#else
/* rvds builds don't support anonymous unions but also don't need
 * 64-bit alignment.
 */
#define NV_ALIGN_POINTER(t, f) t f
#endif
 
#if NVOS_IS_WINDOWS
 
#define NV_NAKED __declspec(naked)
#define NV_LIKELY(c)   (c)
#define NV_UNLIKELY(c) (c)
#define NV_UNUSED
 
#elif defined(__ghs__) // GHS COMP
#define NV_NAKED
#define NV_LIKELY(c)   (c)
#define NV_UNLIKELY(c) (c)
#define NV_UNUSED __attribute__((unused))
 
#elif defined(__GNUC__)
#define NV_NAKED __attribute__((naked))
#define NV_LIKELY(c)   __builtin_expect((c),1)
#define NV_UNLIKELY(c) __builtin_expect((c),0)
#define NV_UNUSED __attribute__((unused))
 
#elif defined(__arm) // ARM RVDS compiler
#define NV_NAKED __asm
#define NV_LIKELY(c)   (c)
#define NV_UNLIKELY(c) (c)
#define NV_UNUSED
 
#else
#error Unknown compiler
#endif
 
#if NVOS_IS_WINDOWS
#define NV_WEAK
#elif defined(__ghs__)
#define NV_WEAK __attribute__((weak))
#elif defined(__GNUC__)
#define NV_WEAK __attribute__((weak))
#elif defined(__arm)
#define NV_WEAK __weak
#else
#error Unknown compiler
#endif
 
// NV_DEBUG_CODE conflicts with the definition of the same name
// in OpenGL/nvInc/nvDebug.h.
#if !defined(NV_DEBUG_CODE)
 
#if NV_DEBUG
#define NV_DEBUG_CODE(x) x
#else
#define NV_DEBUG_CODE(x)
#endif
#endif
 
#define NV_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 
#ifndef NV_MIN
#define NV_MIN(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef NV_MAX
#define NV_MAX(a,b) (((a) > (b)) ? (a) : (b))
#endif
 
#if !defined(NV_OFFSETOF)
    #if defined(__GNUC__)
        #define NV_OFFSETOF(type, member)   __builtin_offsetof(type, member)
    #else
        #define NV_OFFSETOF(type, member)   ((NvUPtr)(&(((type *)0)->member)))
    #endif
#endif
 
#define NV_SIZEOF(s,e)          (sizeof(((s*)0)->e))
 
#define NV_LOWEST_BIT_ONLY(v)   ((NvU32)(v) & (NvU32)-(NvS32)(v))
 
#define NV_IS_POWER_OF_2(v)     (NV_LOWEST_BIT_ONLY(v) == (NvU32)(v))
 
#define NV_WAIT_INFINITE 0xFFFFFFFF
 
#if defined(_PREFAST_)
#define NV_ANALYSIS_ASSUME(x) __analysis_assume(x)
#else
#define NV_ANALYSIS_ASSUME(x)
#endif
 
typedef NvU64 NvPhysAddr64;
 
typedef NvU32 NvRmPhysAddr;
 
static NV_FORCE_INLINE  NvU64
NvDiv64Inline(NvU64 dividend, NvU32 divisor)
{
    if (divisor == 0U) {
        return 0;
    }
    return dividend / divisor;
}
 
#define NvDiv64(dividend, divisor) NvDiv64Inline(dividend, divisor)
 
typedef union NvData32Rec
{
    NvU32 u;
    NvS32 i;
    NvF32 f;
} NvData32;
 
typedef union NvData64Rec
{
    NvU32 u;
    NvS32 i;
    NvF32 f;
    NvU64 u64;
    NvS64 i64;
    NvF64 d;
} NvData64;
 
typedef struct NvPointRec
{
    NvS32 x;
 
    NvS32 y;
} NvPoint;
 
typedef struct NvPointF32Rec
{
    NvF32 x;
 
    NvF32 y;
} NvPointF32;
typedef struct NvRectRec
{
    NvS32 left;
 
    NvS32 top;
 
    NvS32 right;
 
    NvS32 bottom;
} NvRect;
 
typedef struct NvRectF32Rec
{
    NvF32 left;
    NvF32 top;
    NvF32 right;
    NvF32 bottom;
} NvRectF32;
 
typedef struct NvSizeRec
{
    /* width of the surface in pixels */
    NvS32 width;
 
    /* height of the surface in pixels */
    NvS32 height;
} NvSize;
 
#endif
#endif // INCLUDED_NVCOMMON_H