diff --git a/hipamd/CMakeLists.txt b/hipamd/CMakeLists.txt index 537764548f..a4da3b1920 100644 --- a/hipamd/CMakeLists.txt +++ b/hipamd/CMakeLists.txt @@ -193,9 +193,7 @@ if(HIP_PLATFORM STREQUAL "hcc") src/program_state.cpp) set(SOURCE_FILES_DEVICE - src/device_util.cpp - src/hip_ldg.cpp - src/device_functions.cpp) + src/device_util.cpp) execute_process(COMMAND ${HCC_HOME}/bin/hcc-config --ldflags OUTPUT_VARIABLE HCC_LD_FLAGS) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${HCC_LD_FLAGS} -Wl,-Bsymbolic") @@ -238,7 +236,6 @@ endif() # Install hip_hcc if platform is hcc if(HIP_PLATFORM STREQUAL "hcc") install(TARGETS hip_hcc_static hip_hcc hip_device DESTINATION lib) - install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/hip_hc.ll DESTINATION lib) # Install .hipInfo install(FILES ${PROJECT_BINARY_DIR}/.hipInfo DESTINATION lib) diff --git a/hipamd/bin/hipcc b/hipamd/bin/hipcc index 0abf09ed71..d2614297c3 100755 --- a/hipamd/bin/hipcc +++ b/hipamd/bin/hipcc @@ -259,8 +259,7 @@ if($HIP_PLATFORM eq "hcc"){ } if(($HIP_PLATFORM eq "hcc")){ - $ENV{HCC_EXTRA_LIBRARIES}="$HIP_PATH/lib/hip_hc.ll\n"; - $ENV{HIP_HC_IR_FILE}=""; + $ENV{HCC_EXTRA_LIBRARIES}="\n"; } if($HIP_PLATFORM eq "nvcc"){ @@ -533,7 +532,7 @@ if($HIP_PLATFORM eq "hcc" or $HIP_PLATFORM eq "clang"){ print "No valid AMD GPU target was either specified or found. Please specify a valid target using --amdgpu-target=" and die(); } - $ENV{HCC_EXTRA_LIBRARIES}="$HIP_PATH/lib/hip_hc.ll\n"; + $ENV{HCC_EXTRA_LIBRARIES}="\n"; if($HIP_PLATFORM eq "hcc") { $GPU_ARCH_OPT = " --amdgpu-target="; diff --git a/hipamd/docs/markdown/CUDA_Driver_API_functions_supported_by_HIP.md b/hipamd/docs/markdown/CUDA_Driver_API_functions_supported_by_HIP.md index c1c30ae019..7e806886c6 100644 --- a/hipamd/docs/markdown/CUDA_Driver_API_functions_supported_by_HIP.md +++ b/hipamd/docs/markdown/CUDA_Driver_API_functions_supported_by_HIP.md @@ -231,6 +231,11 @@ | 0x02 |*`CU_MEMORYTYPE_DEVICE`* | | | 0x03 |*`CU_MEMORYTYPE_ARRAY`* | | | 0x04 |*`CU_MEMORYTYPE_UNIFIED`* | | +| enum |***`CUcomputemode`*** |***`hipComputeMode`*** | +| 0 |*`CU_COMPUTEMODE_DEFAULT`* |*`hipComputeModeDefault`* | +| 1 |*`CU_COMPUTEMODE_EXCLUSIVE`* |*`hipComputeModeExclusive`* | +| 2 |*`CU_COMPUTEMODE_PROHIBITED`* |*`hipComputeModeProhibited`* | +| 3 |*`CU_COMPUTEMODE_EXCLUSIVE_PROCESS`* |*`hipComputeModeExclusiveProcess`* | | enum |***`CUoccupancy_flags`*** | | | 0x00 |*`CU_OCCUPANCY_DEFAULT`* | | | 0x01 |*`CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE`* | | @@ -243,7 +248,7 @@ | 6 |*`CU_POINTER_ATTRIBUTE_SYNC_MEMOPS`* | | | 7 |*`CU_POINTER_ATTRIBUTE_BUFFER_ID`* | | | 8 |*`CU_POINTER_ATTRIBUTE_IS_MANAGED`* | | -| enum |***`CUmemorytype`*** | | +| enum |***`CUresourcetype`*** | | | 0x00 |*`CU_RESOURCE_TYPE_ARRAY`* | | | 0x01 |*`CU_RESOURCE_TYPE_MIPMAPPED_ARRAY`* | | | 0x02 |*`CU_RESOURCE_TYPE_LINEAR`* | | diff --git a/hipamd/docs/markdown/CUDA_Runtime_API_functions_supported_by_HIP.md b/hipamd/docs/markdown/CUDA_Runtime_API_functions_supported_by_HIP.md index 65528da7fb..dca2683b12 100644 --- a/hipamd/docs/markdown/CUDA_Runtime_API_functions_supported_by_HIP.md +++ b/hipamd/docs/markdown/CUDA_Runtime_API_functions_supported_by_HIP.md @@ -418,11 +418,11 @@ | 1 |*`cudaChannelFormatKindUnsigned`* |*`hipChannelFormatKindUnsigned`* | | 2 |*`cudaChannelFormatKindFloat`* |*`hipChannelFormatKindFloat`* | | 3 |*`cudaChannelFormatKindNone`* |*`hipChannelFormatKindNone`* | -| enum |***`cudaComputeMode`*** | | -| 0 |*`cudaComputeModeDefault`* | | -| 1 |*`cudaComputeModeExclusive`* | | -| 2 |*`cudaComputeModeProhibited`* | | -| 3 |*`cudaComputeModeExclusiveProcess`* | | +| enum |***`cudaComputeMode`*** |***`hipComputeMode`*** | +| 0 |*`cudaComputeModeDefault`* |*`hipComputeModeDefault`* | +| 1 |*`cudaComputeModeExclusive`* |*`hipComputeModeExclusive`* | +| 2 |*`cudaComputeModeProhibited`* |*`hipComputeModeProhibited`* | +| 3 |*`cudaComputeModeExclusiveProcess`* |*`hipComputeModeExclusiveProcess`* | | enum |***`cudaDeviceAttr`*** |***`hipDeviceAttribute_t`*** | | 1 |*`cudaDevAttrMaxThreadsPerBlock`* |*`hipDeviceAttributeMaxThreadsPerBlock`* | | 2 |*`cudaDevAttrMaxBlockDimX`* |*`hipDeviceAttributeMaxBlockDimX`* | diff --git a/hipamd/docs/markdown/hip_deprecated_api_list.md b/hipamd/docs/markdown/hip_deprecated_api_list.md index a96f7f4d3f..dfb202c8ee 100644 --- a/hipamd/docs/markdown/hip_deprecated_api_list.md +++ b/hipamd/docs/markdown/hip_deprecated_api_list.md @@ -1,22 +1,22 @@ -# HIP Deprecated API List +# HIP Deprecated APIs ## HIP Context API CUDA supports cuCtx API, the Driver API that defines "Context" and "Devices" as separate entities. Contexts contain a single device, and a device can theoretically have multiple contexts. HIP initially added limited support for these API to facilitate easy porting from existing driver codes. These API are marked as deprecated now since there are better alternate interface (such as hipSetDevice or the stream API) to achieve the required functions. -###hipCtxCreate -###hipCtxDestroy -###hipCtxPopCurrent -###hipCtxPushCurrent -###hipCtxSetCurrent -###hipCtxGetCurrent -###hipCtxGetDevice -###hipCtxGetApiVersion -###hipCtxGetCacheConfig -###hipCtxSetCacheConfig -###hipCtxSetSharedMemConfig -###hipCtxGetSharedMemConfig -###hipCtxSynchronize -###hipCtxGetFlags -###hipCtxEnablePeerAccess -###hipCtxDisablePeerAccess +### hipCtxCreate +### hipCtxDestroy +### hipCtxPopCurrent +### hipCtxPushCurrent +### hipCtxSetCurrent +### hipCtxGetCurrent +### hipCtxGetDevice +### hipCtxGetApiVersion +### hipCtxGetCacheConfig +### hipCtxSetCacheConfig +### hipCtxSetSharedMemConfig +### hipCtxGetSharedMemConfig +### hipCtxSynchronize +### hipCtxGetFlags +### hipCtxEnablePeerAccess +### hipCtxDisablePeerAccess diff --git a/hipamd/hipify-clang/CMakeLists.txt b/hipamd/hipify-clang/CMakeLists.txt index 8b3fa7e591..5d9070be28 100644 --- a/hipamd/hipify-clang/CMakeLists.txt +++ b/hipamd/hipify-clang/CMakeLists.txt @@ -51,6 +51,10 @@ if(WIN32) target_link_libraries(hipify-clang version) endif() +if ((LLVM_PACKAGE_VERSION VERSION_EQUAL "7") OR (LLVM_PACKAGE_VERSION VERSION_GREATER "7")) + target_link_libraries(hipify-clang clangToolingInclusions) +endif() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS}") if(MSVC) @@ -95,7 +99,7 @@ if (HIPIFY_CLANG_TESTS) message(STATUS "Please install clang 4.0 or higher.") elseif (CUDA_VERSION VERSION_EQUAL "9.0") message(STATUS "Please install clang 6.0 or higher.") - elseif (CUDA_VERSION VERSION_EQUAL "9.1") + elseif ((CUDA_VERSION VERSION_EQUAL "9.1") OR (CUDA_VERSION VERSION_EQUAL "9.2")) message(STATUS "Please install clang 7.0 or higher.") endif() endif() diff --git a/hipamd/hipify-clang/src/CUDA2HipMap.cpp b/hipamd/hipify-clang/src/CUDA2HipMap.cpp index 7d10b35e48..588642ccb5 100644 --- a/hipamd/hipify-clang/src/CUDA2HipMap.cpp +++ b/hipamd/hipify-clang/src/CUDA2HipMap.cpp @@ -24,7 +24,7 @@ const std::map CUDA_TYPE_NAME_MAP{ {"CUaddress_mode", {"hipAddress_mode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, {"CUarray_cubemap_face", {"hipArray_cubemap_face", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, {"CUarray_format", {"hipArray_format", CONV_TYPE, API_DRIVER}}, - {"CUcomputemode", {"hipComputemode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_RUNTIME ANALOGUE (cudaComputeMode) + {"CUcomputemode", {"hipComputeMode", CONV_TYPE, API_DRIVER}}, // API_RUNTIME ANALOGUE (cudaComputeMode) {"CUmem_advise", {"hipMemAdvise", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_RUNTIME ANALOGUE (cudaComputeMode) {"CUmem_range_attribute", {"hipMemRangeAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_RUNTIME ANALOGUE (cudaMemRangeAttribute) {"CUctx_flags", {"hipCctx_flags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, @@ -236,7 +236,7 @@ const std::map CUDA_TYPE_NAME_MAP{ {"cudaDeviceAttr", {"hipDeviceAttribute_t", CONV_TYPE, API_RUNTIME}}, // API_DRIVER ANALOGUE (CUdevice_attribute) {"cudaDeviceProp", {"hipDeviceProp_t", CONV_TYPE, API_RUNTIME}}, {"cudaDeviceP2PAttr", {"hipDeviceP2PAttribute", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // API_DRIVER ANALOGUE (CUdevice_P2PAttribute) - {"cudaComputeMode", {"hipComputeMode", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // API_DRIVER ANALOGUE (CUcomputemode) + {"cudaComputeMode", {"hipComputeMode", CONV_TYPE, API_RUNTIME}}, // API_DRIVER ANALOGUE (CUcomputemode) {"cudaFuncCache", {"hipFuncCache_t", CONV_CACHE, API_RUNTIME}}, // API_Driver ANALOGUE (CUfunc_cache) {"cudaFuncAttributes", {"hipFuncAttributes", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}}, {"cudaSharedMemConfig", {"hipSharedMemConfig", CONV_TYPE, API_RUNTIME}}, @@ -628,10 +628,10 @@ const std::map CUDA_IDENTIFIER_MAP{ {"CU_AD_FORMAT_FLOAT", {"HIP_AD_FORMAT_FLOAT", CONV_TYPE, API_DRIVER}}, // 0x20 // CUcomputemode enum - {"CU_COMPUTEMODE_DEFAULT", {"hipComputeModeDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0 // API_RUNTIME ANALOGUE (cudaComputeModeDefault = 0) - {"CU_COMPUTEMODE_EXCLUSIVE", {"hipComputeModeExclusive", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 1 // API_RUNTIME ANALOGUE (cudaComputeModeExclusive = 1) - {"CU_COMPUTEMODE_PROHIBITED", {"hipComputeModeProhibited", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 2 // API_RUNTIME ANALOGUE (cudaComputeModeProhibited = 2) - {"CU_COMPUTEMODE_EXCLUSIVE_PROCESS", {"hipComputeModeExclusiveProcess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 3 // API_RUNTIME ANALOGUE (cudaComputeModeExclusiveProcess = 3) + {"CU_COMPUTEMODE_DEFAULT", {"hipComputeModeDefault", CONV_TYPE, API_DRIVER}}, // 0 // API_RUNTIME ANALOGUE (cudaComputeModeDefault = 0) + {"CU_COMPUTEMODE_EXCLUSIVE", {"hipComputeModeExclusive", CONV_TYPE, API_DRIVER}}, // 1 // API_RUNTIME ANALOGUE (cudaComputeModeExclusive = 1) + {"CU_COMPUTEMODE_PROHIBITED", {"hipComputeModeProhibited", CONV_TYPE, API_DRIVER}}, // 2 // API_RUNTIME ANALOGUE (cudaComputeModeProhibited = 2) + {"CU_COMPUTEMODE_EXCLUSIVE_PROCESS", {"hipComputeModeExclusiveProcess", CONV_TYPE, API_DRIVER}}, // 3 // API_RUNTIME ANALOGUE (cudaComputeModeExclusiveProcess = 3) // Memory advise values // {"CUmem_advise_enum", {"hipMemAdvise", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, @@ -1698,10 +1698,10 @@ const std::map CUDA_IDENTIFIER_MAP{ {"cudaDeviceGetP2PAttribute", {"hipDeviceGetP2PAttribute", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED}}, // API_DRIVER ANALOGUE (cuDeviceGetP2PAttribute) // enum cudaComputeMode - {"cudaComputeModeDefault", {"hipComputeModeDefault", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_DEFAULT = 0) - {"cudaComputeModeExclusive", {"hipComputeModeExclusive", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_EXCLUSIVE = 1) - {"cudaComputeModeProhibited", {"hipComputeModeProhibited", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_PROHIBITED = 2) - {"cudaComputeModeExclusiveProcess", {"hipComputeModeExclusiveProcess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 3 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3) + {"cudaComputeModeDefault", {"hipComputeModeDefault", CONV_TYPE, API_RUNTIME}}, // 0 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_DEFAULT = 0) + {"cudaComputeModeExclusive", {"hipComputeModeExclusive", CONV_TYPE, API_RUNTIME}}, // 1 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_EXCLUSIVE = 1) + {"cudaComputeModeProhibited", {"hipComputeModeProhibited", CONV_TYPE, API_RUNTIME}}, // 2 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_PROHIBITED = 2) + {"cudaComputeModeExclusiveProcess", {"hipComputeModeExclusiveProcess", CONV_TYPE, API_RUNTIME}}, // 3 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3) // Device Flags {"cudaGetDeviceFlags", {"hipGetDeviceFlags", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED}}, diff --git a/hipamd/hipify-clang/src/HipifyAction.cpp b/hipamd/hipify-clang/src/HipifyAction.cpp index 7e5ff4357d..21b16e0699 100644 --- a/hipamd/hipify-clang/src/HipifyAction.cpp +++ b/hipamd/hipify-clang/src/HipifyAction.cpp @@ -428,7 +428,11 @@ public: void InclusionDirective(clang::SourceLocation hash_loc, const clang::Token& include_token, StringRef file_name, bool is_angled, clang::CharSourceRange filename_range, const clang::FileEntry* file, StringRef search_path, StringRef relative_path, - const clang::Module* imported) override { + const clang::Module* imported +#if LLVM_VERSION_MAJOR > 6 + , clang::SrcMgr::CharacteristicKind FileType +#endif + ) override { hipifyAction.InclusionDirective(hash_loc, include_token, file_name, is_angled, filename_range, file, search_path, relative_path, imported); } diff --git a/hipamd/hipify-clang/src/LLVMCompat.h b/hipamd/hipify-clang/src/LLVMCompat.h index 3e2fe1aebb..72b6832012 100644 --- a/hipamd/hipify-clang/src/LLVMCompat.h +++ b/hipamd/hipify-clang/src/LLVMCompat.h @@ -23,6 +23,10 @@ namespace llcompat { #define GET_NUM_ARGS() getNumArgs() #endif +#if LLVM_VERSION_MAJOR < 7 + #define LLVM_DEBUG(X) DEBUG(X) +#endif + void PrintStackTraceOnErrorSignal(); /** diff --git a/hipamd/hipify-clang/src/main.cpp b/hipamd/hipify-clang/src/main.cpp index ccf627b147..e420ab0681 100644 --- a/hipamd/hipify-clang/src/main.cpp +++ b/hipamd/hipify-clang/src/main.cpp @@ -132,7 +132,7 @@ int main(int argc, const char **argv) { // Hipify _all_ the things! if (Tool.runAndSave(&actionFactory)) { - DEBUG(llvm::dbgs() << "Skipped some replacements.\n"); + LLVM_DEBUG(llvm::dbgs() << "Skipped some replacements.\n"); } // Either move the tmpfile to the output, or remove it. diff --git a/hipamd/include/hip/hcc_detail/device_functions.h b/hipamd/include/hip/hcc_detail/device_functions.h index ab14727f11..6455fa6cd1 100644 --- a/hipamd/include/hip/hcc_detail/device_functions.h +++ b/hipamd/include/hip/hcc_detail/device_functions.h @@ -24,47 +24,172 @@ THE SOFTWARE. #define HIP_INCLUDE_HIP_HCC_DETAIL_DEVICE_FUNCTIONS_H #include "host_defines.h" +#include "math_fwd.h" +#include #include +#include +#include #include -extern "C" __device__ unsigned int __hip_hc_ir_umul24_int(unsigned int, unsigned int); -extern "C" __device__ signed int __hip_hc_ir_mul24_int(signed int, signed int); -extern "C" __device__ signed int __hip_hc_ir_mulhi_int(signed int, signed int); -extern "C" __device__ unsigned int __hip_hc_ir_umulhi_int(unsigned int, unsigned int); -extern "C" __device__ unsigned int __hip_hc_ir_usad_int(unsigned int, unsigned int, unsigned int); +typedef unsigned long ulong; +typedef unsigned int uint; + +/* +Integer Intrinsics +*/ // integer intrinsic function __poc __clz __ffs __brev -__device__ unsigned int __brev(unsigned int x); -__device__ unsigned long long int __brevll(unsigned long long int x); -__device__ unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); -__device__ unsigned int __clz(int x); -__device__ unsigned int __clzll(long long int x); -__device__ unsigned int __ffs(int x); -__device__ unsigned int __ffsll(long long int x); +__device__ static inline unsigned int __popc(unsigned int input) { + return __builtin_popcount(input); +} +__device__ static inline unsigned int __popcll(unsigned long long int input) { + return __builtin_popcountl(input); +} + +__device__ static inline unsigned int __clz(unsigned int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 32 : __builtin_clz(input); +#else + return input == 0 ? -1 : __builtin_clz(input); +#endif +} + +__device__ static inline unsigned int __clzll(unsigned long long int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 64 : ( input == 0 ? -1 : __builtin_clzl(input) ); +#else + return input == 0 ? -1 : __builtin_clzl(input); +#endif +} + +__device__ static inline unsigned int __clz(int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 32 : ( input > 0 ? __builtin_clz(input) : __builtin_clz(~input) ); +#else + if (input == 0) return -1; + return input > 0 ? __builtin_clz(input) : __builtin_clz(~input); +#endif +} + +__device__ static inline unsigned int __clzll(long long int input) { +#ifdef NVCC_COMPAT + return input == 0 ? 64 : input > 0 ? __builtin_clzl(input) : __builtin_clzl(~input); +#else + if (input == 0) return -1; + return input > 0 ? __builtin_clzl(input) : __builtin_clzl(~input); +#endif +} + +__device__ static inline unsigned int __ffs(unsigned int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctz(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctz(input); +#endif +} + +__device__ static inline unsigned int __ffsll(unsigned long long int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctzl(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctzl(input); +#endif +} + +__device__ static inline unsigned int __ffs(int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctz(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctz(input); +#endif +} + +__device__ static inline unsigned int __ffsll(long long int input) { +#ifdef NVCC_COMPAT + return ( input == 0 ? -1 : __builtin_ctzl(input) ) + 1; +#else + return input == 0 ? -1 : __builtin_ctzl(input); +#endif +} + +__device__ static inline unsigned int __brev(unsigned int input) { return __llvm_bitrev_b32(input); } + +__device__ static inline unsigned long long int __brevll(unsigned long long int input) { + return __llvm_bitrev_b64(input); +} + +__device__ static unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); __device__ static unsigned int __hadd(int x, int y); __device__ static int __mul24(int x, int y); -__device__ long long int __mul64hi(long long int x, long long int y); +__device__ static long long int __mul64hi(long long int x, long long int y); __device__ static int __mulhi(int x, int y); -__device__ unsigned int __popc(unsigned int x); -__device__ unsigned int __popcll(unsigned long long int x); __device__ static int __rhadd(int x, int y); __device__ static unsigned int __sad(int x, int y, int z); __device__ static unsigned int __uhadd(unsigned int x, unsigned int y); __device__ static int __umul24(unsigned int x, unsigned int y); -__device__ unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); +__device__ static unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); __device__ static unsigned int __umulhi(unsigned int x, unsigned int y); __device__ static unsigned int __urhadd(unsigned int x, unsigned int y); __device__ static unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); +struct ucharHolder { + union { + unsigned char c[4]; + unsigned int ui; + }; +} __attribute__((aligned(4))); + +struct uchar2Holder { + union { + unsigned int ui[2]; + unsigned char c[8]; + }; +} __attribute__((aligned(8))); + +__device__ +static inline unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s) { + struct uchar2Holder cHoldVal; + struct ucharHolder cHoldKey; + struct ucharHolder cHoldOut; + cHoldKey.ui = s; + cHoldVal.ui[0] = x; + cHoldVal.ui[1] = y; + cHoldOut.c[0] = cHoldVal.c[cHoldKey.c[0]]; + cHoldOut.c[1] = cHoldVal.c[cHoldKey.c[1]]; + cHoldOut.c[2] = cHoldVal.c[cHoldKey.c[2]]; + cHoldOut.c[3] = cHoldVal.c[cHoldKey.c[3]]; + return cHoldOut.ui; +} + __device__ static inline unsigned int __hadd(int x, int y) { int z = x + y; int sign = z & 0x8000000; int value = z & 0x7FFFFFFF; return ((value) >> 1 || sign); } -__device__ static inline int __mul24(int x, int y) { return __hip_hc_ir_mul24_int(x, y); } -__device__ static inline int __mulhi(int x, int y) { return __hip_hc_ir_mulhi_int(x, y); } + +__device__ static inline int __mul24(int x, int y) { + return __ockl_mul24_i32(x, y); +} + +__device__ static inline long long __mul64hi(long long int x, long long int y) { + ulong x0 = (ulong)x & 0xffffffffUL; + long x1 = x >> 32; + ulong y0 = (ulong)y & 0xffffffffUL; + long y1 = y >> 32; + ulong z0 = x0*y0; + long t = x1*y0 + (z0 >> 32); + long z1 = t & 0xffffffffL; + long z2 = t >> 32; + z1 = x0*y1 + z1; + return x1*y1 + z2 + (z1 >> 32); +} + +__device__ static inline int __mulhi(int x, int y) { + return __ockl_mul_hi_i32(x, y); +} + __device__ static inline int __rhadd(int x, int y) { int z = x + y + 1; int sign = z & 0x8000000; @@ -78,57 +203,307 @@ __device__ static inline unsigned int __uhadd(unsigned int x, unsigned int y) { return (x + y) >> 1; } __device__ static inline int __umul24(unsigned int x, unsigned int y) { - return __hip_hc_ir_umul24_int(x, y); + return __ockl_mul24_u32(x, y); } + +__device__ +static inline unsigned long long __umul64hi(unsigned long long int x, unsigned long long int y) { + ulong x0 = x & 0xffffffffUL; + ulong x1 = x >> 32; + ulong y0 = y & 0xffffffffUL; + ulong y1 = y >> 32; + ulong z0 = x0*y0; + ulong t = x1*y0 + (z0 >> 32); + ulong z1 = t & 0xffffffffUL; + ulong z2 = t >> 32; + z1 = x0*y1 + z1; + return x1*y1 + z2 + (z1 >> 32); +} + __device__ static inline unsigned int __umulhi(unsigned int x, unsigned int y) { - return __hip_hc_ir_umulhi_int(x, y); + return __ockl_mul_hi_u32(x, y); } __device__ static inline unsigned int __urhadd(unsigned int x, unsigned int y) { return (x + y + 1) >> 1; } __device__ static inline unsigned int __usad(unsigned int x, unsigned int y, unsigned int z) { - return __hip_hc_ir_usad_int(x, y, z); + return __ockl_sad_u32(x, y, z); } -extern __device__ __attribute__((const)) unsigned int __mbcnt_lo(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.lo"); -extern __device__ __attribute__((const)) unsigned int __mbcnt_hi(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.hi"); - __device__ static inline unsigned int __lane_id() { return __mbcnt_hi(-1, __mbcnt_lo(-1, 0)); } /* -Rounding modes are not yet supported in HIP +HIP specific device functions */ -__device__ float __double2float_rd(double x); -__device__ float __double2float_rn(double x); -__device__ float __double2float_ru(double x); -__device__ float __double2float_rz(double x); +// utility union type +union __u { + int i; + unsigned int u; + float f; +}; -__device__ int __double2hiint(double x); +__device__ static inline unsigned __hip_ds_bpermute(int index, unsigned src) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_bpermute(index, tmp.i); + return tmp.u; +} -__device__ int __double2int_rd(double x); -__device__ int __double2int_rn(double x); -__device__ int __double2int_ru(double x); -__device__ int __double2int_rz(double x); +__device__ static inline float __hip_ds_bpermutef(int index, float src) { + __u tmp; tmp.f = src; + tmp.i = __llvm_amdgcn_ds_bpermute(index, tmp.i); + return tmp.f; +} -__device__ long long int __double2ll_rd(double x); -__device__ long long int __double2ll_rn(double x); -__device__ long long int __double2ll_ru(double x); -__device__ long long int __double2ll_rz(double x); +__device__ static inline unsigned __hip_ds_permute(int index, unsigned src) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_permute(index, tmp.i); + return tmp.u; +} -__device__ int __double2loint(double x); +__device__ static inline float __hip_ds_permutef(int index, float src) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_permute(index, tmp.i); + return tmp.u; +} -__device__ unsigned int __double2uint_rd(double x); -__device__ unsigned int __double2uint_rn(double x); -__device__ unsigned int __double2uint_ru(double x); -__device__ unsigned int __double2uint_rz(double x); +__device__ static inline unsigned __hip_ds_swizzle(unsigned int src, int pattern) { + __u tmp; tmp.u = src; + tmp.i = __llvm_amdgcn_ds_swizzle(tmp.i, pattern); + return tmp.u; +} +__device__ static inline float __hip_ds_swizzlef(float src, int pattern) { + __u tmp; tmp.f = src; + tmp.i = __llvm_amdgcn_ds_swizzle(tmp.i, pattern); + return tmp.f; +} -__device__ unsigned long long int __double2ull_rd(double x); -__device__ unsigned long long int __double2ull_rn(double x); -__device__ unsigned long long int __double2ull_ru(double x); -__device__ unsigned long long int __double2ull_rz(double x); +__device__ static inline int __hip_move_dpp(int src, int dpp_ctrl, int row_mask, + int bank_mask, bool bound_ctrl) { + return __llvm_amdgcn_move_dpp(src, dpp_ctrl, row_mask, bank_mask, bound_ctrl); +} + +static constexpr int warpSize = 64; + + __device__ +inline +int __shfl(int var, int src_lane, int width = warpSize) { + int self = __lane_id(); + int index = src_lane + (self & ~(width-1)); + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl(unsigned int var, int src_lane, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl(tmp.i, src_lane, width); + return tmp.u; +} +__device__ +inline +float __shfl(float var, int src_lane, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl(tmp.i, src_lane, width); + return tmp.f; +} +__device__ +inline +double __shfl(double var, int src_lane, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl(tmp.i, src_lane, width); + return (double) tmp.f; +} + + __device__ +inline +int __shfl_up(int var, unsigned int lane_delta, int width = warpSize) { + int self = __lane_id(); + int index = self - lane_delta; + index = (index < (self & ~(width-1)))?self:index; + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl_up(unsigned int var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl_up(tmp.i, lane_delta, width); + return tmp.u; +} +__device__ +inline +float __shfl_up(float var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl_up(tmp.i, lane_delta, width); + return tmp.f; +} +__device__ +inline +double __shfl_up(double var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl_up(tmp.i, lane_delta, width); + return (double) tmp.f; +} + +__device__ +inline +int __shfl_down(int var, unsigned int lane_delta, int width = warpSize) { + int self = __lane_id(); + int index = self + lane_delta; + index = (int)((self&(width-1))+lane_delta) >= width?self:index; + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl_down(unsigned int var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl_down(tmp.i, lane_delta, width); + return tmp.u; +} +__device__ +inline +float __shfl_down(float var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl_down(tmp.i, lane_delta, width); + return tmp.f; +} +__device__ +inline +double __shfl_down(double var, unsigned int lane_delta, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl_down(tmp.i, lane_delta, width); + return (double) tmp.f; +} + +__device__ +inline +int __shfl_xor(int var, int lane_mask, int width = warpSize) { + int self = __lane_id(); + int index = self^lane_mask; + index = index >= ((self+width)&~(width-1))?self:index; + return __llvm_amdgcn_ds_bpermute(index<<2, var); +} +__device__ +inline +unsigned int __shfl_xor(unsigned int var, int lane_mask, int width = warpSize) { + __u tmp; tmp.u = var; + tmp.i = __shfl_xor(tmp.i, lane_mask, width); + return tmp.u; +} +__device__ +inline +float __shfl_xor(float var, int lane_mask, int width = warpSize) { + __u tmp; tmp.f = var; + tmp.i = __shfl_xor(tmp.i, lane_mask, width); + return tmp.f; +} +__device__ +inline +double __shfl_xor(double var, int lane_mask, int width = warpSize) { + __u tmp; tmp.f = (float) var; + tmp.i = __shfl_xor(tmp.i, lane_mask, width); + return (double) tmp.f; +} + +#define MASK1 0x00ff00ff +#define MASK2 0xff00ff00 + +__device__ static inline char4 __hip_hc_add8pk(char4 in1, char4 in2) { + char4 out; + unsigned one1 = in1.w & MASK1; + unsigned one2 = in2.w & MASK1; + out.w = (one1 + one2) & MASK1; + one1 = in1.w & MASK2; + one2 = in2.w & MASK2; + out.w = out.w | ((one1 + one2) & MASK2); + return out; +} + +__device__ static inline char4 __hip_hc_sub8pk(char4 in1, char4 in2) { + char4 out; + unsigned one1 = in1.w & MASK1; + unsigned one2 = in2.w & MASK1; + out.w = (one1 - one2) & MASK1; + one1 = in1.w & MASK2; + one2 = in2.w & MASK2; + out.w = out.w | ((one1 - one2) & MASK2); + return out; +} + +__device__ static inline char4 __hip_hc_mul8pk(char4 in1, char4 in2) { + char4 out; + unsigned one1 = in1.w & MASK1; + unsigned one2 = in2.w & MASK1; + out.w = (one1 * one2) & MASK1; + one1 = in1.w & MASK2; + one2 = in2.w & MASK2; + out.w = out.w | ((one1 * one2) & MASK2); + return out; +} + +/* + * Rounding modes are not yet supported in HIP + * TODO: Conversion functions are not correct, need to fix when BE is ready +*/ + +__device__ static inline float __double2float_rd(double x) { return (double)x; } +__device__ static inline float __double2float_rn(double x) { return (double)x; } +__device__ static inline float __double2float_ru(double x) { return (double)x; } +__device__ static inline float __double2float_rz(double x) { return (double)x; } + +__device__ static inline int __double2hiint(double x) { + static_assert(sizeof(double) == 2 * sizeof(int), ""); + + int tmp[2]; + __builtin_memcpy(tmp, &x, sizeof(tmp)); + + return tmp[1]; +} +__device__ static inline int __double2loint(double x) { + static_assert(sizeof(double) == 2 * sizeof(int), ""); + + int tmp[2]; + __builtin_memcpy(tmp, &x, sizeof(tmp)); + + return tmp[0]; +} + +__device__ static inline int __double2int_rd(double x) { return (int)x; } +__device__ static inline int __double2int_rn(double x) { return (int)x; } +__device__ static inline int __double2int_ru(double x) { return (int)x; } +__device__ static inline int __double2int_rz(double x) { return (int)x; } + +__device__ static inline long long int __double2ll_rd(double x) { return (long long int)x; } +__device__ static inline long long int __double2ll_rn(double x) { return (long long int)x; } +__device__ static inline long long int __double2ll_ru(double x) { return (long long int)x; } +__device__ static inline long long int __double2ll_rz(double x) { return (long long int)x; } + +__device__ static inline unsigned int __double2uint_rd(double x) { return (unsigned int)x; } +__device__ static inline unsigned int __double2uint_rn(double x) { return (unsigned int)x; } +__device__ static inline unsigned int __double2uint_ru(double x) { return (unsigned int)x; } +__device__ static inline unsigned int __double2uint_rz(double x) { return (unsigned int)x; } + +__device__ static inline unsigned long long int __double2ull_rd(double x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __double2ull_rn(double x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __double2ull_ru(double x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __double2ull_rz(double x) { + return (unsigned long long int)x; +} + +__device__ static inline long long int __double_as_longlong(double x) { + static_assert(sizeof(long long) == sizeof(double), ""); + + long long tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return tmp; +} -__device__ long long int __double_as_longlong(double x); /* __device__ unsigned short __float2half_rn(float x); __device__ float __half2float(unsigned short); @@ -143,72 +518,457 @@ CUDA implements half as unsigned short whereas, HIP doesn't. */ -__device__ int __float2int_rd(float x); -__device__ int __float2int_rn(float x); -__device__ int __float2int_ru(float x); -__device__ int __float2int_rz(float x); +__device__ static inline int __float2int_rd(float x) { return (int)__ocml_floor_f32(x); } +__device__ static inline int __float2int_rn(float x) { return (int)__ocml_rint_f32(x); } +__device__ static inline int __float2int_ru(float x) { return (int)__ocml_ceil_f32(x); } +__device__ static inline int __float2int_rz(float x) { return (int)__ocml_trunc_f32(x); } -__device__ long long int __float2ll_rd(float x); -__device__ long long int __float2ll_rn(float x); -__device__ long long int __float2ll_ru(float x); -__device__ long long int __float2ll_rz(float x); +__device__ static inline long long int __float2ll_rd(float x) { return (long long int)x; } +__device__ static inline long long int __float2ll_rn(float x) { return (long long int)x; } +__device__ static inline long long int __float2ll_ru(float x) { return (long long int)x; } +__device__ static inline long long int __float2ll_rz(float x) { return (long long int)x; } -__device__ unsigned int __float2uint_rd(float x); -__device__ unsigned int __float2uint_rn(float x); -__device__ unsigned int __float2uint_ru(float x); -__device__ unsigned int __float2uint_rz(float x); +__device__ static inline unsigned int __float2uint_rd(float x) { return (unsigned int)x; } +__device__ static inline unsigned int __float2uint_rn(float x) { return (unsigned int)x; } +__device__ static inline unsigned int __float2uint_ru(float x) { return (unsigned int)x; } +__device__ static inline unsigned int __float2uint_rz(float x) { return (unsigned int)x; } -__device__ unsigned long long int __float2ull_rd(float x); -__device__ unsigned long long int __float2ull_rn(float x); -__device__ unsigned long long int __float2ull_ru(float x); -__device__ unsigned long long int __float2ull_rz(float x); +__device__ static inline unsigned long long int __float2ull_rd(float x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __float2ull_rn(float x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __float2ull_ru(float x) { + return (unsigned long long int)x; +} +__device__ static inline unsigned long long int __float2ull_rz(float x) { + return (unsigned long long int)x; +} -__device__ int __float_as_int(float x); -__device__ unsigned int __float_as_uint(float x); -__device__ double __hiloint2double(int hi, int lo); -__device__ double __int2double_rn(int x); +__device__ static inline int __float_as_int(float x) { + static_assert(sizeof(int) == sizeof(float), ""); -__device__ float __int2float_rd(int x); -__device__ float __int2float_rn(int x); -__device__ float __int2float_ru(int x); -__device__ float __int2float_rz(int x); + int tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); -__device__ float __int_as_float(int x); + return tmp; +} -__device__ double __ll2double_rd(long long int x); -__device__ double __ll2double_rn(long long int x); -__device__ double __ll2double_ru(long long int x); -__device__ double __ll2double_rz(long long int x); +__device__ static inline unsigned int __float_as_uint(float x) { + static_assert(sizeof(unsigned int) == sizeof(float), ""); -__device__ float __ll2float_rd(long long int x); -__device__ float __ll2float_rn(long long int x); -__device__ float __ll2float_ru(long long int x); -__device__ float __ll2float_rz(long long int x); + unsigned int tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); -__device__ double __longlong_as_double(long long int x); + return tmp; +} -__device__ double __uint2double_rn(int x); +__device__ static inline double __hiloint2double(int hi, int lo) { + static_assert(sizeof(double) == sizeof(uint64_t), ""); -__device__ float __uint2float_rd(unsigned int x); -__device__ float __uint2float_rn(unsigned int x); -__device__ float __uint2float_ru(unsigned int x); -__device__ float __uint2float_rz(unsigned int x); + uint64_t tmp0 = (static_cast(hi) << 32ull) | static_cast(lo); + double tmp1; + __builtin_memcpy(&tmp1, &tmp0, sizeof(tmp0)); -__device__ float __uint_as_float(unsigned int x); + return tmp1; +} -__device__ double __ull2double_rd(unsigned long long int x); -__device__ double __ull2double_rn(unsigned long long int x); -__device__ double __ull2double_ru(unsigned long long int x); -__device__ double __ull2double_rz(unsigned long long int x); +__device__ static inline double __int2double_rn(int x) { return (double)x; } -__device__ float __ull2float_rd(unsigned long long int x); -__device__ float __ull2float_rn(unsigned long long int x); -__device__ float __ull2float_ru(unsigned long long int x); -__device__ float __ull2float_rz(unsigned long long int x); +__device__ static inline float __int2float_rd(int x) { return (float)x; } +__device__ static inline float __int2float_rn(int x) { return (float)x; } +__device__ static inline float __int2float_ru(int x) { return (float)x; } +__device__ static inline float __int2float_rz(int x) { return (float)x; } -__device__ char4 __hip_hc_add8pk(char4, char4); -__device__ char4 __hip_hc_sub8pk(char4, char4); -__device__ char4 __hip_hc_mul8pk(char4, char4); +__device__ static inline float __int_as_float(int x) { + static_assert(sizeof(float) == sizeof(int), ""); + + float tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return tmp; +} + +__device__ static inline double __ll2double_rd(long long int x) { return (double)x; } +__device__ static inline double __ll2double_rn(long long int x) { return (double)x; } +__device__ static inline double __ll2double_ru(long long int x) { return (double)x; } +__device__ static inline double __ll2double_rz(long long int x) { return (double)x; } + +__device__ static inline float __ll2float_rd(long long int x) { return (float)x; } +__device__ static inline float __ll2float_rn(long long int x) { return (float)x; } +__device__ static inline float __ll2float_ru(long long int x) { return (float)x; } +__device__ static inline float __ll2float_rz(long long int x) { return (float)x; } + +__device__ static inline double __longlong_as_double(long long int x) { + static_assert(sizeof(double) == sizeof(long long), ""); + + double tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return x; +} + +__device__ static inline double __uint2double_rn(int x) { return (double)x; } + +__device__ static inline float __uint2float_rd(unsigned int x) { return (float)x; } +__device__ static inline float __uint2float_rn(unsigned int x) { return (float)x; } +__device__ static inline float __uint2float_ru(unsigned int x) { return (float)x; } +__device__ static inline float __uint2float_rz(unsigned int x) { return (float)x; } + +__device__ static inline float __uint_as_float(unsigned int x) { + static_assert(sizeof(float) == sizeof(unsigned int), ""); + + float tmp; + __builtin_memcpy(&tmp, &x, sizeof(tmp)); + + return tmp; +} + +__device__ static inline double __ull2double_rd(unsigned long long int x) { return (double)x; } +__device__ static inline double __ull2double_rn(unsigned long long int x) { return (double)x; } +__device__ static inline double __ull2double_ru(unsigned long long int x) { return (double)x; } +__device__ static inline double __ull2double_rz(unsigned long long int x) { return (double)x; } + +__device__ static inline float __ull2float_rd(unsigned long long int x) { return (float)x; } +__device__ static inline float __ull2float_rn(unsigned long long int x) { return (float)x; } +__device__ static inline float __ull2float_ru(unsigned long long int x) { return (float)x; } +__device__ static inline float __ull2float_rz(unsigned long long int x) { return (float)x; } + +#if defined(__HCC__) +#define __HCC_OR_HIP_CLANG__ 1 +#elif defined(__clang__) && defined(__HIP__) +#define __HCC_OR_HIP_CLANG__ 1 +#else +#define __HCC_OR_HIP_CLANG__ 0 +#endif + +#ifdef __HCC_OR_HIP_CLANG__ + +#ifdef __HIP_DEVICE_COMPILE__ + +// Clock functions +__device__ +inline +long long int __clock64() { return (long long int) __builtin_amdgcn_s_memrealtime(); } + +__device__ +inline +long long int __clock() { return (long long int) __builtin_amdgcn_s_memrealtime(); } + +// hip.amdgcn.bc - named sync +__device__ +inline +void __named_sync(int a, int b) { __builtin_amdgcn_s_barrier(); } + +#endif // __HIP_DEVICE_COMPILE__ + +// warp vote function __all __any __ballot +__device__ +inline +int __all(int predicate) { + return __ockl_wfall_i32(predicate); +} + +__device__ +inline +int __any(int predicate) { +#ifdef NVCC_COMPAT + if (__ockl_wfany_i32(predicate) != 0) + return 1; + else + return 0; +#else + return __ockl_wfany_i32(predicate); +#endif +} + +// XXX from llvm/include/llvm/IR/InstrTypes.h +#define ICMP_NE 33 + +__device__ +inline +unsigned long long int __ballot(int predicate) { + return __llvm_amdgcn_icmp_i32(predicate, 0, ICMP_NE); +} + +__device__ +inline +unsigned long long int __ballot64(int predicate) { + return __llvm_amdgcn_icmp_i32(predicate, 0, ICMP_NE); +} + +// hip.amdgcn.bc - lanemask +__device__ +inline +int64_t __lanemask_gt() +{ + int32_t activelane = __ockl_activelane_u32(); + int64_t ballot = __ballot64(1); + if (activelane != 63) { + int64_t tmp = (~0UL) << (activelane + 1); + return tmp & ballot; + } + return 0; +} + +__device__ +inline +int64_t __lanemask_lt() +{ + int32_t activelane = __ockl_activelane_u32(); + int64_t ballot = __ballot64(1); + if (activelane == 0) + return 0; + return ballot; +} + +__device__ inline void* __local_to_generic(void* p) { return p; } + +#ifdef __HIP_DEVICE_COMPILE__ +__device__ +inline +void* __get_dynamicgroupbaseptr() +{ + // Get group segment base pointer. + return (char*)__local_to_generic((void*)__to_local(__llvm_amdgcn_groupstaticsize())); +} +#else +__device__ +void* __get_dynamicgroupbaseptr(); +#endif // __HIP_DEVICE_COMPILE__ + +__device__ +inline +void *__amdgcn_get_dynamicgroupbaseptr() { + return __get_dynamicgroupbaseptr(); +} + + + +// hip.amdgcn.bc - sync threads +#define __CLK_LOCAL_MEM_FENCE 0x01 +typedef unsigned __cl_mem_fence_flags; + +typedef 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, + __memory_scope_all_svm_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES, + __memory_scope_sub_group = __OPENCL_MEMORY_SCOPE_SUB_GROUP +} __memory_scope; + +// enum values aligned with what clang uses in EmitAtomicExpr() +typedef 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_seq_cst = __ATOMIC_SEQ_CST +} __memory_order; + +__device__ +inline +static void +__atomic_work_item_fence(__cl_mem_fence_flags flags, __memory_order order, __memory_scope scope) +{ + // We're tying global-happens-before and local-happens-before together as does HSA + if (order != __memory_order_relaxed) { + switch (scope) { + case __memory_scope_work_item: + break; + case __memory_scope_sub_group: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_sg(); break; + case __memory_order_release: __llvm_fence_rel_sg(); break; + case __memory_order_acq_rel: __llvm_fence_ar_sg(); break; + case __memory_order_seq_cst: __llvm_fence_sc_sg(); break; + } + break; + case __memory_scope_work_group: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_wg(); break; + case __memory_order_release: __llvm_fence_rel_wg(); break; + case __memory_order_acq_rel: __llvm_fence_ar_wg(); break; + case __memory_order_seq_cst: __llvm_fence_sc_wg(); break; + } + break; + case __memory_scope_device: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_dev(); break; + case __memory_order_release: __llvm_fence_rel_dev(); break; + case __memory_order_acq_rel: __llvm_fence_ar_dev(); break; + case __memory_order_seq_cst: __llvm_fence_sc_dev(); break; + } + break; + case __memory_scope_all_svm_devices: + switch (order) { + case __memory_order_relaxed: break; + case __memory_order_acquire: __llvm_fence_acq_sys(); break; + case __memory_order_release: __llvm_fence_rel_sys(); break; + case __memory_order_acq_rel: __llvm_fence_ar_sys(); break; + case __memory_order_seq_cst: __llvm_fence_sc_sys(); break; + } + break; + } + } +} + +// Memory Fence Functions +__device__ +inline +static void __threadfence() +{ + __atomic_work_item_fence(0, __memory_order_seq_cst, __memory_scope_device); +} + +__device__ +inline +static void __threadfence_block() +{ + __atomic_work_item_fence(0, __memory_order_seq_cst, __memory_scope_work_group); +} + +__device__ +inline +static void __threadfence_system() +{ + __atomic_work_item_fence(0, __memory_order_seq_cst, __memory_scope_all_svm_devices); +} + +#endif // __HCC_OR_HIP_CLANG__ + +#ifdef __HCC__ + +/** + * extern __shared__ + */ + +// Macro to replace extern __shared__ declarations +// to local variable definitions +#define HIP_DYNAMIC_SHARED(type, var) type* var = (type*)__get_dynamicgroupbaseptr(); + +#define HIP_DYNAMIC_SHARED_ATTRIBUTE + + +#elif defined(__clang__) && defined(__HIP__) + +#pragma push_macro("__DEVICE__") +#define __DEVICE__ extern "C" __device__ __attribute__((always_inline)) \ + __attribute__((weak)) + +__DEVICE__ +inline +void __assert_fail(const char * __assertion, + const char *__file, + unsigned int __line, + const char *__function) +{ + // Ignore all the args for now. + __builtin_trap(); +} + +__DEVICE__ +inline +void __assertfail(const char * __assertion, + const char *__file, + unsigned int __line, + const char *__function, + size_t charsize) +{ + // ignore all the args for now. + __builtin_trap(); +} + +__device__ +inline +static void __work_group_barrier(__cl_mem_fence_flags flags, __memory_scope scope) +{ + if (flags) { + __atomic_work_item_fence(flags, __memory_order_release, scope); + __builtin_amdgcn_s_barrier(); + __atomic_work_item_fence(flags, __memory_order_acquire, scope); + } else { + __builtin_amdgcn_s_barrier(); + } +} + +__device__ +inline +static void __barrier(int n) +{ + __work_group_barrier((__cl_mem_fence_flags)n, __memory_scope_work_group); +} + +__device__ +inline +__attribute__((noduplicate)) +void __syncthreads() +{ + __barrier(__CLK_LOCAL_MEM_FENCE); +} + +// hip.amdgcn.bc - device routine +/* + HW_ID Register bit structure + WAVE_ID 3:0 Wave buffer slot number. 0-9. + SIMD_ID 5:4 SIMD which the wave is assigned to within the CU. + PIPE_ID 7:6 Pipeline from which the wave was dispatched. + CU_ID 11:8 Compute Unit the wave is assigned to. + SH_ID 12 Shader Array (within an SE) the wave is assigned to. + SE_ID 14:13 Shader Engine the wave is assigned to. + TG_ID 19:16 Thread-group ID + VM_ID 23:20 Virtual Memory ID + QUEUE_ID 26:24 Queue from which this wave was dispatched. + STATE_ID 29:27 State ID (graphics only, not compute). + ME_ID 31:30 Micro-engine ID. + */ + +#define HW_ID 4 + +#define HW_ID_CU_ID_SIZE 4 +#define HW_ID_CU_ID_OFFSET 8 + +#define HW_ID_SE_ID_SIZE 2 +#define HW_ID_SE_ID_OFFSET 13 + +/* + Encoding of parameter bitmask + HW_ID 5:0 HW_ID + OFFSET 10:6 Range: 0..31 + SIZE 15:11 Range: 1..32 + */ + +#define GETREG_IMMED(SZ,OFF,REG) (SZ << 11) | (OFF << 6) | REG + +__device__ +inline +unsigned __smid(void) +{ + unsigned cu_id = __builtin_amdgcn_s_getreg( + GETREG_IMMED(HW_ID_CU_ID_SIZE, HW_ID_CU_ID_OFFSET, HW_ID)); + unsigned se_id = __builtin_amdgcn_s_getreg( + GETREG_IMMED(HW_ID_SE_ID_SIZE, HW_ID_SE_ID_OFFSET, HW_ID)); + + /* Each shader engine has 16 CU */ + return (se_id << HW_ID_CU_ID_SIZE) + cu_id; +} + +#pragma push_macro("__DEVICE__") + +// Macro to replace extern __shared__ declarations +// to local variable definitions +#define HIP_DYNAMIC_SHARED(type, var) \ + type* var = (type*)__amdgcn_get_dynamicgroupbaseptr(); + +#define HIP_DYNAMIC_SHARED_ATTRIBUTE + + +#endif //defined(__clang__) && defined(__HIP__) // loop unrolling diff --git a/hipamd/include/hip/hcc_detail/device_library_decls.h b/hipamd/include/hip/hcc_detail/device_library_decls.h new file mode 100644 index 0000000000..2a14b0b814 --- /dev/null +++ b/hipamd/include/hip/hcc_detail/device_library_decls.h @@ -0,0 +1,80 @@ +/* +Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. + +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. + +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. 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. +*/ + +/** + * @file hcc_detail/device_library_decls.h + * @brief Contains declarations for types and functions in device library. + */ + +#ifndef HIP_INCLUDE_HIP_HCC_DETAIL_DEVICE_LIBRARY_DECLS_H +#define HIP_INCLUDE_HIP_HCC_DETAIL_DEVICE_LIBRARY_DECLS_H + +#include "hip/hcc_detail/host_defines.h" + +extern "C" __device__ __attribute__((const)) bool __ockl_wfany_i32(int); +extern "C" __device__ __attribute__((const)) bool __ockl_wfall_i32(int); +extern "C" __device__ uint __ockl_activelane_u32(void); + +extern "C" __device__ __attribute__((const)) uint __ockl_mul24_u32(uint, uint); +extern "C" __device__ __attribute__((const)) int __ockl_mul24_i32(int, int); +extern "C" __device__ __attribute__((const)) uint __ockl_mul_hi_u32(uint, uint); +extern "C" __device__ __attribute__((const)) int __ockl_mul_hi_i32(int, int); +extern "C" __device__ __attribute__((const)) uint __ockl_sad_u32(uint, uint, uint); + +extern "C" __device__ __attribute__((const)) float __ocml_floor_f32(float); +extern "C" __device__ __attribute__((const)) float __ocml_rint_f32(float); +extern "C" __device__ __attribute__((const)) float __ocml_ceil_f32(float); +extern "C" __device__ __attribute__((const)) float __ocml_trunc_f32(float); + +extern "C" __device__ __attribute__((const)) float __ocml_fmin_f32(float, float); +extern "C" __device__ __attribute__((const)) float __ocml_fmax_f32(float, float); + +// Introduce local address space +#define __local __attribute__((address_space(3))) + +#ifdef __HIP_DEVICE_COMPILE__ +__device__ inline static __local void* __to_local(unsigned x) { return (__local void*)x; } +#endif //__HIP_DEVICE_COMPILE__ + +// __llvm_fence* functions from device-libs/irif/src/fence.ll +extern "C" __device__ void __llvm_fence_acq_sg(void); +extern "C" __device__ void __llvm_fence_acq_wg(void); +extern "C" __device__ void __llvm_fence_acq_dev(void); +extern "C" __device__ void __llvm_fence_acq_sys(void); + +extern "C" __device__ void __llvm_fence_rel_sg(void); +extern "C" __device__ void __llvm_fence_rel_wg(void); +extern "C" __device__ void __llvm_fence_rel_dev(void); +extern "C" __device__ void __llvm_fence_rel_sys(void); + +extern "C" __device__ void __llvm_fence_ar_sg(void); +extern "C" __device__ void __llvm_fence_ar_wg(void); +extern "C" __device__ void __llvm_fence_ar_dev(void); +extern "C" __device__ void __llvm_fence_ar_sys(void); + + +extern "C" __device__ void __llvm_fence_sc_sg(void); +extern "C" __device__ void __llvm_fence_sc_wg(void); +extern "C" __device__ void __llvm_fence_sc_dev(void); +extern "C" __device__ void __llvm_fence_sc_sys(void); + +#endif diff --git a/hipamd/include/hip/hcc_detail/hip_ldg.h b/hipamd/include/hip/hcc_detail/hip_ldg.h index 281550cd4c..a5b80b0a1b 100644 --- a/hipamd/include/hip/hcc_detail/hip_ldg.h +++ b/hipamd/include/hip/hcc_detail/hip_ldg.h @@ -23,54 +23,81 @@ THE SOFTWARE. #ifndef HIP_INCLUDE_HIP_HCC_DETAIL_HIP_LDG_H #define HIP_INCLUDE_HIP_HCC_DETAIL_HIP_LDG_H -#if defined __HCC__ -#if __hcc_workweek__ >= 16164 +#if defined(__HCC_OR_HIP_CLANG__) +#if __hcc_workweek__ >= 16164 || defined(__HIP_CLANG_ONLY__) #include "hip_vector_types.h" #include "host_defines.h" -__device__ char __ldg(const char*); -__device__ char2 __ldg(const char2*); -__device__ char4 __ldg(const char4*); -__device__ signed char __ldg(const signed char*); -__device__ unsigned char __ldg(const unsigned char*); +__device__ inline static char __ldg(const char* ptr) { return *ptr; } -__device__ short __ldg(const short*); -__device__ short2 __ldg(const short2*); -__device__ short4 __ldg(const short4*); -__device__ unsigned short __ldg(const unsigned short*); +__device__ inline static char2 __ldg(const char2* ptr) { return *ptr; } -__device__ int __ldg(const int*); -__device__ int2 __ldg(const int2*); -__device__ int4 __ldg(const int4*); -__device__ unsigned int __ldg(const unsigned int*); +__device__ inline static char4 __ldg(const char4* ptr) { return *ptr; } + +__device__ inline static signed char __ldg(const signed char* ptr) { return ptr[0]; } + +__device__ inline static unsigned char __ldg(const unsigned char* ptr) { return ptr[0]; } -__device__ long __ldg(const long*); -__device__ unsigned long __ldg(const unsigned long*); +__device__ inline static short __ldg(const short* ptr) { return ptr[0]; } -__device__ long long __ldg(const long long*); -__device__ longlong2 __ldg(const longlong2*); -__device__ unsigned long long __ldg(const unsigned long long*); +__device__ inline static short2 __ldg(const short2* ptr) { return ptr[0]; } -__device__ uchar2 __ldg(const uchar2*); -__device__ uchar4 __ldg(const uchar4*); +__device__ inline static short4 __ldg(const short4* ptr) { return ptr[0]; } -__device__ ushort2 __ldg(const ushort2*); +__device__ inline static unsigned short __ldg(const unsigned short* ptr) { return ptr[0]; } -__device__ uint2 __ldg(const uint2*); -__device__ uint4 __ldg(const uint4*); -__device__ ulonglong2 __ldg(const ulonglong2*); +__device__ inline static int __ldg(const int* ptr) { return ptr[0]; } -__device__ float __ldg(const float*); -__device__ float2 __ldg(const float2*); -__device__ float4 __ldg(const float4*); +__device__ inline static int2 __ldg(const int2* ptr) { return ptr[0]; } -__device__ double __ldg(const double*); -__device__ double2 __ldg(const double2*); +__device__ inline static int4 __ldg(const int4* ptr) { return ptr[0]; } -#endif // __hcc_workweek__ +__device__ inline static unsigned int __ldg(const unsigned int* ptr) { return ptr[0]; } -#endif // __HCC__ + +__device__ inline static long __ldg(const long* ptr) { return ptr[0]; } + +__device__ inline static unsigned long __ldg(const unsigned long* ptr) { return ptr[0]; } + + +__device__ inline static long long __ldg(const long long* ptr) { return ptr[0]; } + +__device__ inline static longlong2 __ldg(const longlong2* ptr) { return ptr[0]; } + +__device__ inline static unsigned long long __ldg(const unsigned long long* ptr) { return ptr[0]; } + + +__device__ inline static uchar2 __ldg(const uchar2* ptr) { return ptr[0]; } + +__device__ inline static uchar4 __ldg(const uchar4* ptr) { return ptr[0]; } + + +__device__ inline static ushort2 __ldg(const ushort2* ptr) { return ptr[0]; } + + +__device__ inline static uint2 __ldg(const uint2* ptr) { return ptr[0]; } + +__device__ inline static uint4 __ldg(const uint4* ptr) { return ptr[0]; } + + +__device__ inline static ulonglong2 __ldg(const ulonglong2* ptr) { return ptr[0]; } + + +__device__ inline static float __ldg(const float* ptr) { return ptr[0]; } + +__device__ inline static float2 __ldg(const float2* ptr) { return ptr[0]; } + +__device__ inline static float4 __ldg(const float4* ptr) { return ptr[0]; } + + +__device__ inline static double __ldg(const double* ptr) { return ptr[0]; } + +__device__ inline static double2 __ldg(const double2* ptr) { return ptr[0]; } + +#endif // __hcc_workweek__ || defined(__HIP_CLANG_ONLY__) + +#endif // defined(__HCC_OR_HIP_CLANG__) #endif // HIP_LDG_H diff --git a/hipamd/include/hip/hcc_detail/hip_runtime.h b/hipamd/include/hip/hcc_detail/hip_runtime.h index 57192fdf82..c8ac3b4ef4 100644 --- a/hipamd/include/hip/hcc_detail/hip_runtime.h +++ b/hipamd/include/hip/hcc_detail/hip_runtime.h @@ -110,9 +110,9 @@ extern int HIP_TRACE_API; #include #include #include +#include #if __HCC__ #include -#include #endif // __HCC__ // TODO-HCC remove old definitions ; ~1602 hcc supports __HCC_ACCELERATOR__ define. @@ -184,45 +184,11 @@ extern int HIP_TRACE_API; #define __HCC_C__ #endif -// TODO - hipify-clang - change to use the function call. -//#define warpSize hc::__wavesize() -static constexpr int warpSize = 64; - -#define clock_t long long int -__device__ long long int clock64(); -__device__ clock_t clock(); - // abort __device__ void abort(); -// warp vote function __all __any __ballot -__device__ int __all(int input); -__device__ int __any(int input); -__device__ unsigned long long int __ballot(int input); - #if __HIP_ARCH_GFX701__ == 0 -// warp shuffle functions -#ifdef __cplusplus -__device__ int __shfl(int input, int lane, int width = warpSize); -__device__ int __shfl_up(int input, unsigned int lane_delta, int width = warpSize); -__device__ int __shfl_down(int input, unsigned int lane_delta, int width = warpSize); -__device__ int __shfl_xor(int input, int lane_mask, int width = warpSize); -__device__ float __shfl(float input, int lane, int width = warpSize); -__device__ float __shfl_up(float input, unsigned int lane_delta, int width = warpSize); -__device__ float __shfl_down(float input, unsigned int lane_delta, int width = warpSize); -__device__ float __shfl_xor(float input, int lane_mask, int width = warpSize); -#else -__device__ int __shfl(int input, int lane, int width); -__device__ int __shfl_up(int input, unsigned int lane_delta, int width); -__device__ int __shfl_down(int input, unsigned int lane_delta, int width); -__device__ int __shfl_xor(int input, int lane_mask, int width); -__device__ float __shfl(float input, int lane, int width); -__device__ float __shfl_up(float input, unsigned int lane_delta, int width); -__device__ float __shfl_down(float input, unsigned int lane_delta, int width); -__device__ float __shfl_xor(float input, int lane_mask, int width); -#endif //__cplusplus - __device__ unsigned __hip_ds_bpermute(int index, unsigned src); __device__ float __hip_ds_bpermutef(int index, float src); __device__ unsigned __hip_ds_permute(int index, unsigned src); @@ -235,85 +201,15 @@ __device__ int __hip_move_dpp(int src, int dpp_ctrl, int row_mask, int bank_mask #endif //__HIP_ARCH_GFX803__ == 1 -__host__ __device__ int min(int arg1, int arg2); -__host__ __device__ int max(int arg1, int arg2); +__device__ inline static int min(int arg1, int arg2) { + return (arg1 < arg2) ? arg1 : arg2; +} +__device__ inline static int max(int arg1, int arg2) { + return (arg1 > arg2) ? arg1 : arg2; +} -__device__ void* __get_dynamicgroupbaseptr(); - - -/** - * CUDA 8 device function features - - */ - - -/** - * Kernel launching - */ - -/** - *------------------------------------------------------------------------------------------------- - *------------------------------------------------------------------------------------------------- - * @defgroup Fence Fence Functions - * @{ - * - * - * @warning The HIP memory fence functions are currently not supported yet. - * If any of those threadfence stubs are reached by the application, you should set "export - *HSA_DISABLE_CACHE=1" to disable L1 and L2 caches. - * - * - * On AMD platforms, the threadfence* routines are currently empty stubs. - */ - -extern __attribute__((const)) __device__ void __hip_hc_threadfence() __asm("__llvm_fence_sc_dev"); -extern __attribute__((const)) __device__ void __hip_hc_threadfence_block() __asm( - "__llvm_fence_sc_wg"); - - -/** - * @brief threadfence_block makes writes visible to threads running in same block. - * - * @Returns void - * - * @param void - * - * @warning __threadfence_block is a stub and map to no-op. - */ -// __device__ void __threadfence_block(void); -__device__ static inline void __threadfence_block(void) { return __hip_hc_threadfence_block(); } - -/** - * @brief threadfence makes wirtes visible to other threads running on same GPU. - * - * @Returns void - * - * @param void - * - * @warning __threadfence is a stub and map to no-op, application should set "export - * HSA_DISABLE_CACHE=1" to disable both L1 and L2 caches. - */ -// __device__ void __threadfence(void) __attribute__((deprecated("Provided for compile-time -// compatibility, not yet functional"))); -__device__ static inline void __threadfence(void) { return __hip_hc_threadfence(); } - -/** - * @brief threadfence_system makes writes to pinned system memory visible on host CPU. - * - * @Returns void - * - * @param void - * - * @warning __threadfence_system is a stub and map to no-op. - */ -//__device__ void __threadfence_system(void) __attribute__((deprecated("Provided with workaround -//configuration, see hip_kernel_language.md for details"))); -__device__ void __threadfence_system(void); - -// doxygen end Fence Fence -/** - * @} - */ +__host__ inline static int min(int arg1, int arg2) { return std::min(arg1, arg2); } +__host__ inline static int max(int arg1, int arg2) { return std::max(arg1, arg2); } #endif // __HCC_OR_HIP_CLANG__ @@ -424,17 +320,6 @@ extern void ihipPostLaunchKernel(const char* kernelName, hipStream_t stream, gri #endif //__HCC_CPP__ -/** - * extern __shared__ - */ - -// Macro to replace extern __shared__ declarations -// to local variable definitions -#define HIP_DYNAMIC_SHARED(type, var) type* var = (type*)__get_dynamicgroupbaseptr(); - -#define HIP_DYNAMIC_SHARED_ATTRIBUTE - - /** * @defgroup HIP-ENV HIP Environment Variables * @{ @@ -553,33 +438,6 @@ extern const __device__ __attribute__((weak)) __hip_builtin_gridDim_t gridDim; #define hipGridDim_y gridDim.y #define hipGridDim_z gridDim.z -#pragma push_macro("__DEVICE__") -#define __DEVICE__ extern "C" __device__ __attribute__((always_inline)) \ - __attribute__((weak)) - -__DEVICE__ void __device_trap() __asm("llvm.trap"); - -__DEVICE__ void inline __assert_fail(const char * __assertion, - const char *__file, - unsigned int __line, - const char *__function) -{ - // Ignore all the args for now. - __device_trap(); -} - -extern "C" __device__ __attribute__((noduplicate)) void __syncthreads(); -extern "C" __device__ void *__amdgcn_get_dynamicgroupbaseptr(); - -// Macro to replace extern __shared__ declarations -// to local variable definitions -#define HIP_DYNAMIC_SHARED(type, var) \ - type* var = (type*)__amdgcn_get_dynamicgroupbaseptr(); - -#define HIP_DYNAMIC_SHARED_ATTRIBUTE - -#pragma push_macro("__DEVICE__") - #include #endif diff --git a/hipamd/include/hip/hcc_detail/hip_runtime_api.h b/hipamd/include/hip/hcc_detail/hip_runtime_api.h index 0a80a583c7..573ae39af9 100644 --- a/hipamd/include/hip/hcc_detail/hip_runtime_api.h +++ b/hipamd/include/hip/hcc_detail/hip_runtime_api.h @@ -2621,6 +2621,13 @@ hipError_t hipBindTextureToArray(struct texture& tex, hipArray return ihipBindTextureToArrayImpl(dim, readMode, array, desc, &tex); } +template +inline static hipError_t hipBindTextureToArray(struct texture *tex, + hipArray_const_t array, + const struct hipChannelFormatDesc* desc) { + return ihipBindTextureToArrayImpl(dim, readMode, array, *desc, tex); +} + // C API hipError_t hipBindTextureToMipmappedArray(const textureReference* tex, hipMipmappedArray_const_t mipmappedArray, diff --git a/hipamd/include/hip/hcc_detail/hip_vector_types.h b/hipamd/include/hip/hcc_detail/hip_vector_types.h index 7cd250e257..cf7058af2b 100644 --- a/hipamd/include/hip/hcc_detail/hip_vector_types.h +++ b/hipamd/include/hip/hcc_detail/hip_vector_types.h @@ -34,1132 +34,679 @@ THE SOFTWARE. #include "hip/hcc_detail/host_defines.h" -#define MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x) {} \ - __device__ __host__ ~type() {} - -#define MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x), y(val.y) {} \ - __device__ __host__ ~type() {} - -#define MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x), y(val.y), z(val.z) {} \ - __device__ __host__ ~type() {} - -#define MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(type) \ - __device__ __host__ type() {} \ - __device__ __host__ type(const type& val) : x(val.x), y(val.y), z(val.z), w(val.w) {} \ - __device__ __host__ ~type() {} - -#define MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val) {} - -#define MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val), y(val) {} \ - __device__ __host__ type(type1 val1, type1 val2) : x(val1), y(val2) {} - -#define MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val), y(val), z(val) {} \ - __device__ __host__ type(type1 val1, type1 val2, type1 val3) : x(val1), y(val2), z(val3) {} - -#define MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(type, type1) \ - __device__ __host__ type(type1 val) : x(val), y(val), z(val), w(val) {} \ - __device__ __host__ type(type1 val1, type1 val2, type1 val3, type1 val4) \ - : x(val1), y(val2), z(val3), w(val4) {} - -struct uchar1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(uchar1) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uchar1, signed long long) - +#if defined(__clang__) + #define __NATIVE_VECTOR__(n, ...) __attribute__((ext_vector_type(n))) +#elif defined(__GNUC__) // N.B.: GCC does not support .xyzw syntax. + #define __ROUND_UP_TO_NEXT_POT__(x) \ + (1 << (31 - __builtin_clz(x) + (x > (1 << (31 - __builtin_clz(x)))))) + #define __NATIVE_VECTOR__(n, T) \ + __attribute__((vector_size(__ROUND_UP_TO_NEXT_POT__(n) * sizeof(T)))) #endif - unsigned char x; -} __attribute__((aligned(1))); +#if defined(__cplusplus) + #include -struct uchar2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(uchar2) + template struct HIP_vector_base; - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uchar2, signed long long) -#endif - union { - struct { - unsigned char x, y; + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(1, T); + + union { + Native_vec_ data; + struct { + T x; + }; }; - unsigned short a; - }; -} __attribute__((aligned(2))); - -struct uchar3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(uchar3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uchar3, signed long long) -#endif - unsigned char x, y, z; -}; - -struct uchar4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(uchar4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uchar4, signed long long) -#endif - union { - struct { - unsigned char x, y, z, w; - }; - unsigned int a; - }; -} __attribute__((aligned(4))); - - -struct char1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(char1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(char1, signed long long) -#endif - signed char x; -} __attribute__((aligned(1))); - -struct char2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(char2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(char2, signed long long) -#endif - union { - struct { - signed char x, y; - }; - unsigned short a; - }; -} __attribute__((aligned(2))); - -struct char3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(char3) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(char3, signed long long) -#endif - signed char x, y, z; -}; - -struct char4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(char4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(char4, signed long long) -#endif - union { - struct { - signed char x, y, z, w; - }; - unsigned int a; - }; -} __attribute__((aligned(4))); - - -struct ushort1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(ushort1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ushort1, signed long long) -#endif - unsigned short x; -} __attribute__((aligned(2))); - -struct ushort2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(ushort2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ushort2, signed long long) -#endif - union { - struct { - unsigned short x, y; - }; - unsigned int a; - }; -} __attribute__((aligned(4))); - -struct ushort3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(ushort3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ushort3, signed long long) -#endif - unsigned short x, y, z; -}; - -struct ushort4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(ushort4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ushort4, signed long long) -#endif - union { - struct { - unsigned short x, y, z, w; - }; - unsigned int a, b; - }; -} __attribute__((aligned(8))); - -struct short1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(short1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(short1, signed long long) -#endif - signed short x; -} __attribute__((aligned(2))); - -struct short2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(short2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(short2, signed long long) -#endif - union { - struct { - signed short x, y; - }; - unsigned int a; }; -} __attribute__((aligned(4))); + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(2, T); -struct short3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(short3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(short3, signed long long) -#endif - signed short x, y, z; -}; - -struct short4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(short4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(short4, signed long long) -#endif - union { - struct { - signed short x, y, z, w; + union { + Native_vec_ data; + struct { + T x; + T y; + }; }; - unsigned int a, b; }; -} __attribute__((aligned(8))); - -struct uint1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(uint1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(uint1, signed long long) -#endif - unsigned int x; -} __attribute__((aligned(4))); - -struct uint2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(uint2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(uint2, signed long long) -#endif - unsigned int x, y; -} __attribute__((aligned(8))); - -struct uint3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(uint3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(uint3, signed long long) -#endif - unsigned int x, y, z; -}; - -struct uint4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(uint4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(uint4, signed long long) -#endif - unsigned int x, y, z, w; -} __attribute__((aligned(16))); - -struct int1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(int1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(int1, signed long long) -#endif - signed int x; -} __attribute__((aligned(4))); - -struct int2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(int2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(int2, signed long long) -#endif - signed int x, y; -} __attribute__((aligned(8))); - -struct int3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(int3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(int3, signed long long) -#endif - signed int x, y, z; -}; - -struct int4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(int4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(int4, signed long long) -#endif - signed int x, y, z, w; -} __attribute__((aligned(16))); - - -struct float1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(float1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(float1, signed long long) -#endif - float x; -} __attribute__((aligned(4))); - -struct float2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(float2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(float2, signed long long) -#endif - float x, y; -} __attribute__((aligned(8))); - -struct float3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(float3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(float3, signed long long) -#endif - float x, y, z; -}; - -struct float4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(float4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(float4, signed long long) -#endif - float x, y, z, w; -} __attribute__((aligned(16))); - - -struct double1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(double1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(double1, signed long long) -#endif - double x; -} __attribute__((aligned(8))); - -struct double2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(double2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(double2, signed long long) -#endif - double x, y; -} __attribute__((aligned(16))); - -struct double3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(double3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(double3, signed long long) -#endif - double x, y, z; -}; - -struct double4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(double4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(double4, signed long long) -#endif - double x, y, z, w; -} __attribute__((aligned(32))); - - -struct ulong1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(ulong1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulong1, signed long long) -#endif - unsigned long x; -} __attribute__((aligned(8))); - -struct ulong2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(ulong2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulong2, signed long long) -#endif - unsigned long x, y; -} __attribute__((aligned(16))); - -struct ulong3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(ulong3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulong3, signed long long) -#endif - unsigned long x, y, z; -}; - -struct ulong4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(ulong4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulong4, signed long long) -#endif - unsigned long x, y, z, w; -} __attribute__((aligned(32))); - - -struct long1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(long1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(long1, signed long long) -#endif - signed long x; -} __attribute__((aligned(8))); - -struct long2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(long2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(long2, signed long long) -#endif - signed long x, y; -} __attribute__((aligned(16))); - -struct long3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(long3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(long3, signed long long) -#endif - signed long x, y, z; -}; - -struct long4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(long4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(long4, signed long long) -#endif - signed long x, y, z, w; -} __attribute__((aligned(32))); - - -struct ulonglong1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(ulonglong1, signed long long) -#endif - unsigned long long x; -} __attribute__((aligned(8))); - -struct ulonglong2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(ulonglong2, signed long long) -#endif - unsigned long long x, y; -} __attribute__((aligned(16))); - -struct ulonglong3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(ulonglong3, signed long long) -#endif - unsigned long long x, y, z; -}; - -struct ulonglong4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(ulonglong4, signed long long) -#endif - unsigned long long x, y, z, w; -} __attribute__((aligned(32))); - - -struct longlong1 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_ONE_COMPONENT(longlong1) - - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed char) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed short) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed int) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, float) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, double) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_ONE_COMPONENT(longlong1, signed long long) -#endif - signed long long x; -} __attribute__((aligned(8))); - -struct longlong2 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_TWO_COMPONENT(longlong2) - - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed char) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed short) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed int) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, float) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, double) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_TWO_COMPONENT(longlong2, signed long long) -#endif - signed long long x, y; -} __attribute__((aligned(16))); - -struct longlong3 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_THREE_COMPONENT(longlong3) - - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed char) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed short) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed int) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, float) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, double) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_THREE_COMPONENT(longlong3, signed long long) -#endif - signed long long x, y, z; -}; - -struct longlong4 { -#ifdef __cplusplus - public: - MAKE_DEFAULT_CONSTRUCTOR_FOUR_COMPONENT(longlong4) - - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed char) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed short) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed int) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, float) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, double) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, unsigned long long) - MAKE_COMPONENT_CONSTRUCTOR_FOUR_COMPONENT(longlong4, signed long long) -#endif - signed long x, y, z, w; -} __attribute__((aligned(32))); - -#define DECLOP_MAKE_ONE_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x) { \ - struct type ret; \ - ret.x = x; \ - return ret; \ + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(3, T); + + union { + Native_vec_ data; + struct { + T x; + T y; + T z; + }; + }; + }; + + template + struct HIP_vector_base { + typedef T Native_vec_ __NATIVE_VECTOR__(4, T); + + union { + Native_vec_ data; + struct { + T x; + T y; + T z; + T w; + }; + }; + }; + + template + struct HIP_vector_type : public HIP_vector_base { + using HIP_vector_base::data; + using typename HIP_vector_base::Native_vec_; + + __host__ __device__ + HIP_vector_type() = default; + template< + typename U, + typename std::enable_if< + std::is_convertible{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type(U x) noexcept + { + for (auto i = 0u; i != rank; ++i) data[i] = x; + } + template< // TODO: constrain based on type as well. + typename... Us, + typename std::enable_if::type* = nullptr> + __host__ __device__ + HIP_vector_type(Us... xs) noexcept { data = Native_vec_{xs...}; } + __host__ __device__ + HIP_vector_type(const HIP_vector_type&) = default; + __host__ __device__ + HIP_vector_type(HIP_vector_type&&) = default; + __host__ __device__ + ~HIP_vector_type() = default; + + __host__ __device__ + HIP_vector_type& operator=(const HIP_vector_type&) = default; + __host__ __device__ + HIP_vector_type& operator=(HIP_vector_type&&) = default; + + // Operators + __host__ __device__ + HIP_vector_type& operator++() noexcept + { + return *this += HIP_vector_type{1}; + } + __host__ __device__ + HIP_vector_type operator++(int) noexcept + { + auto tmp(*this); + ++*this; + return tmp; + } + __host__ __device__ + HIP_vector_type& operator--() noexcept + { + return *this -= HIP_vector_type{1}; + } + __host__ __device__ + HIP_vector_type operator--(int) noexcept + { + auto tmp(*this); + --*this; + return tmp; + } + __host__ __device__ + HIP_vector_type& operator+=(const HIP_vector_type& x) noexcept + { + data += x.data; + return *this; + } + __host__ __device__ + HIP_vector_type& operator-=(const HIP_vector_type& x) noexcept + { + data -= x.data; + return *this; + } + template< + typename U, + typename std::enable_if< + std::is_convertible{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator-=(U x) noexcept + { + return *this -= HIP_vector_type{x}; + } + __host__ __device__ + HIP_vector_type& operator*=(const HIP_vector_type& x) noexcept + { + data *= x.data; + return *this; + } + __host__ __device__ + HIP_vector_type& operator/=(const HIP_vector_type& x) noexcept + { + data /= x.data; + return *this; + } + + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type operator-() noexcept + { + auto tmp(*this); + tmp.data = -tmp.data; + return tmp; + } + + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type operator~() noexcept + { + HIP_vector_type r{*this}; + r.data = ~r.data; + return r; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator%=(const HIP_vector_type& x) noexcept + { + data %= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator^=(const HIP_vector_type& x) noexcept + { + data ^= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator|=(const HIP_vector_type& x) noexcept + { + data |= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator&=(const HIP_vector_type& x) noexcept + { + data &= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator>>=(const HIP_vector_type& x) noexcept + { + data >>= x.data; + return *this; + } + template< + typename U = T, + typename std::enable_if{}>::type* = nullptr> + __host__ __device__ + HIP_vector_type& operator<<=(const HIP_vector_type& x) noexcept + { + data <<= x.data; + return *this; + } + }; + + + template + __host__ __device__ + inline + HIP_vector_type operator+( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} += y; + } + template + __host__ __device__ + inline + HIP_vector_type operator+( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} += y; + } + template + __host__ __device__ + inline + HIP_vector_type operator+( + U x, const HIP_vector_type& y) noexcept + { + return y + x; } -#define DECLOP_MAKE_TWO_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x, comp y) { \ - struct type ret; \ - ret.x = x; \ - ret.y = y; \ - return ret; \ + template + __host__ __device__ + inline + HIP_vector_type operator-( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} -= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator-( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} -= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator-( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} -= y; } -#define DECLOP_MAKE_THREE_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x, comp y, comp z) { \ - struct type ret; \ - ret.x = x; \ - ret.y = y; \ - ret.z = z; \ - return ret; \ + template + __host__ __device__ + inline + HIP_vector_type operator*( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} *= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator*( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} *= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator*( + U x, const HIP_vector_type& y) noexcept + { + return y * x; } -#define DECLOP_MAKE_FOUR_COMPONENT(comp, type) \ - __device__ __host__ static inline struct type make_##type(comp x, comp y, comp z, comp w) { \ - struct type ret; \ - ret.x = x; \ - ret.y = y; \ - ret.z = z; \ - ret.w = w; \ - return ret; \ + template + __host__ __device__ + inline + HIP_vector_type operator/( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} /= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator/( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} /= y; + } + template + __host__ __device__ + inline + HIP_vector_type operator/( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} /= y; + } + + template + __host__ __device__ + inline + bool operator==( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + auto tmp = x.data == y.data; + for (auto i = 0u; i != n; ++i) if (tmp[i] == 0) return false; + return true; + } + template + __host__ __device__ + inline + bool operator==(const HIP_vector_type& x, U y) noexcept + { + return x == HIP_vector_type{y}; + } + template + __host__ __device__ + inline + bool operator==(U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} == y; + } + + template + __host__ __device__ + inline + bool operator!=( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return !(x == y); + } + template + __host__ __device__ + inline + bool operator!=(const HIP_vector_type& x, U y) noexcept + { + return !(x == y); + } + template + __host__ __device__ + inline + bool operator!=(U x, const HIP_vector_type& y) noexcept + { + return !(x == y); + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator%( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} %= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator%( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} %= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator%( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} %= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator^( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} ^= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator^( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} ^= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator^( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} ^= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator|( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} |= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator|( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} |= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator|( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} |= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator&( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} &= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator&( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} &= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator&( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} &= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator>>( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} >>= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator>>( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} >>= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator>>( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} >>= y; + } + + template< + typename T, + unsigned int n, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator<<( + const HIP_vector_type& x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} <<= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator<<( + const HIP_vector_type& x, U y) noexcept + { + return HIP_vector_type{x} <<= y; + } + template< + typename T, + unsigned int n, + typename U, + typename std::enable_if{}>* = nullptr> + inline + HIP_vector_type operator<<( + U x, const HIP_vector_type& y) noexcept + { + return HIP_vector_type{x} <<= y; + } + + #define __MAKE_VECTOR_TYPE__(CUDA_name, T) \ + using CUDA_name##1 = HIP_vector_type;\ + using CUDA_name##2 = HIP_vector_type;\ + using CUDA_name##3 = HIP_vector_type;\ + using CUDA_name##4 = HIP_vector_type; +#else + #define __MAKE_VECTOR_TYPE__(CUDA_name, T) \ + typedef T CUDA_name##_impl1 __NATIVE_VECTOR__(1, T);\ + typedef T CUDA_name##_impl2 __NATIVE_VECTOR__(2, T);\ + typedef T CUDA_name##_impl3 __NATIVE_VECTOR__(3, T);\ + typedef T CUDA_name##_impl4 __NATIVE_VECTOR__(4, T);\ + typedef struct {\ + union {\ + CUDA_name##_impl1 data;\ + struct {\ + T x;\ + };\ + };\ + } CUDA_name##1;\ + typedef struct {\ + union {\ + CUDA_name##_impl2 data;\ + struct {\ + T x;\ + T y;\ + };\ + };\ + } CUDA_name##2;\ + typedef struct {\ + union {\ + CUDA_name##_impl3 data;\ + struct {\ + T x;\ + T y;\ + T z;\ + };\ + };\ + } CUDA_name##3;\ + typedef struct {\ + union {\ + CUDA_name##_impl4 data;\ + struct {\ + T x;\ + T y;\ + T z;\ + T w;\ + };\ + };\ + } CUDA_name##4; +#endif + +__MAKE_VECTOR_TYPE__(uchar, unsigned char); +__MAKE_VECTOR_TYPE__(char, char); +__MAKE_VECTOR_TYPE__(ushort, unsigned short); +__MAKE_VECTOR_TYPE__(short, short); +__MAKE_VECTOR_TYPE__(uint, unsigned int); +__MAKE_VECTOR_TYPE__(int, int); +__MAKE_VECTOR_TYPE__(ulong, unsigned long); +__MAKE_VECTOR_TYPE__(long, long); +__MAKE_VECTOR_TYPE__(ulonglong, unsigned long long); +__MAKE_VECTOR_TYPE__(longlong, long long); +__MAKE_VECTOR_TYPE__(float, float); +__MAKE_VECTOR_TYPE__(double, double); + +#define DECLOP_MAKE_ONE_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x) { type r = {x}; return r; } + +#define DECLOP_MAKE_TWO_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x, comp y) { type r = {x, y}; return r; } + +#define DECLOP_MAKE_THREE_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x, comp y, comp z) { type r = {x, y, z}; return r; } + +#define DECLOP_MAKE_FOUR_COMPONENT(comp, type) \ + __device__ __host__ \ + static \ + inline \ + type make_##type(comp x, comp y, comp z, comp w) { \ + type r = {x, y, z, w}; \ + return r; \ } DECLOP_MAKE_ONE_COMPONENT(unsigned char, uchar1); @@ -1222,2894 +769,4 @@ DECLOP_MAKE_TWO_COMPONENT(signed long, longlong2); DECLOP_MAKE_THREE_COMPONENT(signed long, longlong3); DECLOP_MAKE_FOUR_COMPONENT(signed long, longlong4); - -#if __cplusplus - -#define DECLOP_1VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - return ret; \ - } - -#define DECLOP_1VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - return ret; \ - } - -#define DECLOP_1VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - return lhs; \ - } - -#define DECLOP_1VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - return val; \ - } - -#define DECLOP_1VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - val.x op; \ - return ret; \ - } - -#define DECLOP_1VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return lhs.x op rhs.x; \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return lhs.x op rhs.x; \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return lhs.x op rhs.x; \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return lhs.x op rhs.x; \ - } - -#define DECLOP_1VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - return ret; \ - } - -#define DECLOP_1VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { return op rhs.x; } - -/* - Two Element Access -*/ - -#define DECLOP_2VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - ret.y = lhs.y op rhs.y; \ - return ret; \ - } - -#define DECLOP_2VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - ret.y = lhs.y * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - ret.y = lhs * rhs.y; \ - return ret; \ - } - -#define DECLOP_2VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - lhs.y op rhs.y; \ - return lhs; \ - } - -#define DECLOP_2VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - op val.y; \ - return val; \ - } - -#define DECLOP_2VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - ret.y = val.y; \ - val.x op; \ - val.y op; \ - return ret; \ - } - -#define DECLOP_2VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y); \ - } - -#define DECLOP_2VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - ret.y = op rhs.y; \ - return ret; \ - } - -#define DECLOP_2VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { \ - return (op rhs.x) && (op rhs.y); \ - } - - -/* - Three Element Access -*/ - -#define DECLOP_3VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - ret.y = lhs.y op rhs.y; \ - ret.z = lhs.z op rhs.z; \ - return ret; \ - } - -#define DECLOP_3VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - ret.y = lhs.y * rhs; \ - ret.z = lhs.z * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - ret.y = lhs * rhs.y; \ - ret.z = lhs * rhs.z; \ - return ret; \ - } - -#define DECLOP_3VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - lhs.y op rhs.y; \ - lhs.z op rhs.z; \ - return lhs; \ - } - -#define DECLOP_3VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - op val.y; \ - op val.z; \ - return val; \ - } - -#define DECLOP_3VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - ret.y = val.y; \ - ret.z = val.z; \ - val.x op; \ - val.y op; \ - val.z op; \ - return ret; \ - } - -#define DECLOP_3VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z); \ - } - -#define DECLOP_3VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - ret.y = op rhs.y; \ - ret.z = op rhs.z; \ - return ret; \ - } - -#define DECLOP_3VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { \ - return (op rhs.x) && (op rhs.y) && (op rhs.z); \ - } - - -/* - Four Element Access -*/ - -#define DECLOP_4VAR_2IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(const type& lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs.x op rhs.x; \ - ret.y = lhs.y op rhs.y; \ - ret.z = lhs.z op rhs.z; \ - ret.w = lhs.w op rhs.w; \ - return ret; \ - } - -#define DECLOP_4VAR_SCALE_PRODUCT(type, type1) \ - __device__ __host__ static inline type operator*(const type& lhs, type1 rhs) { \ - type ret; \ - ret.x = lhs.x * rhs; \ - ret.y = lhs.y * rhs; \ - ret.z = lhs.z * rhs; \ - ret.w = lhs.w * rhs; \ - return ret; \ - } \ - \ - __device__ __host__ static inline type operator*(type1 lhs, const type& rhs) { \ - type ret; \ - ret.x = lhs * rhs.x; \ - ret.y = lhs * rhs.y; \ - ret.z = lhs * rhs.z; \ - ret.w = lhs * rhs.w; \ - return ret; \ - } - -#define DECLOP_4VAR_ASSIGN(type, op) \ - __device__ __host__ static inline type& operator op(type& lhs, const type& rhs) { \ - lhs.x op rhs.x; \ - lhs.y op rhs.y; \ - lhs.z op rhs.z; \ - lhs.w op rhs.w; \ - return lhs; \ - } - -#define DECLOP_4VAR_PREOP(type, op) \ - __device__ __host__ static inline type& operator op(type& val) { \ - op val.x; \ - op val.y; \ - op val.z; \ - op val.w; \ - return val; \ - } - -#define DECLOP_4VAR_POSTOP(type, op) \ - __device__ __host__ static inline type operator op(type& val, int) { \ - type ret; \ - ret.x = val.x; \ - ret.y = val.y; \ - ret.z = val.z; \ - ret.w = val.w; \ - val.x op; \ - val.y op; \ - val.z op; \ - val.w op; \ - return ret; \ - } - -#define DECLOP_4VAR_COMP(type, op) \ - __device__ __host__ static inline bool operator op(type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } \ - __device__ __host__ static inline bool operator op(type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } \ - __device__ __host__ static inline bool operator op(const type& lhs, const type& rhs) { \ - return (lhs.x op rhs.x) && (lhs.y op rhs.y) && (lhs.z op rhs.z) && (lhs.w op rhs.w); \ - } - -#define DECLOP_4VAR_1IN_1OUT(type, op) \ - __device__ __host__ static inline type operator op(type& rhs) { \ - type ret; \ - ret.x = op rhs.x; \ - ret.y = op rhs.y; \ - ret.z = op rhs.z; \ - ret.w = op rhs.w; \ - return ret; \ - } - -#define DECLOP_4VAR_1IN_BOOLOUT(type, op) \ - __device__ __host__ static inline bool operator op(type& rhs) { \ - return (op rhs.x) && (op rhs.y) && (op rhs.z) && (op rhs.w); \ - } - - -/* -Overloading operators -*/ - -// UNSIGNED CHAR1 - -DECLOP_1VAR_2IN_1OUT(uchar1, +) -DECLOP_1VAR_2IN_1OUT(uchar1, -) -DECLOP_1VAR_2IN_1OUT(uchar1, *) -DECLOP_1VAR_2IN_1OUT(uchar1, /) -DECLOP_1VAR_2IN_1OUT(uchar1, %) -DECLOP_1VAR_2IN_1OUT(uchar1, &) -DECLOP_1VAR_2IN_1OUT(uchar1, |) -DECLOP_1VAR_2IN_1OUT(uchar1, ^) -DECLOP_1VAR_2IN_1OUT(uchar1, <<) -DECLOP_1VAR_2IN_1OUT(uchar1, >>) - - -DECLOP_1VAR_ASSIGN(uchar1, +=) -DECLOP_1VAR_ASSIGN(uchar1, -=) -DECLOP_1VAR_ASSIGN(uchar1, *=) -DECLOP_1VAR_ASSIGN(uchar1, /=) -DECLOP_1VAR_ASSIGN(uchar1, %=) -DECLOP_1VAR_ASSIGN(uchar1, &=) -DECLOP_1VAR_ASSIGN(uchar1, |=) -DECLOP_1VAR_ASSIGN(uchar1, ^=) -DECLOP_1VAR_ASSIGN(uchar1, <<=) -DECLOP_1VAR_ASSIGN(uchar1, >>=) - -DECLOP_1VAR_PREOP(uchar1, ++) -DECLOP_1VAR_PREOP(uchar1, --) - -DECLOP_1VAR_POSTOP(uchar1, ++) -DECLOP_1VAR_POSTOP(uchar1, --) - -DECLOP_1VAR_COMP(uchar1, ==) -DECLOP_1VAR_COMP(uchar1, !=) -DECLOP_1VAR_COMP(uchar1, <) -DECLOP_1VAR_COMP(uchar1, >) -DECLOP_1VAR_COMP(uchar1, <=) -DECLOP_1VAR_COMP(uchar1, >=) - -DECLOP_1VAR_COMP(uchar1, &&) -DECLOP_1VAR_COMP(uchar1, ||) - -DECLOP_1VAR_1IN_1OUT(uchar1, ~) -DECLOP_1VAR_1IN_BOOLOUT(uchar1, !) - -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, float) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, double) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(uchar1, signed long long) - -// UNSIGNED CHAR2 - -DECLOP_2VAR_2IN_1OUT(uchar2, +) -DECLOP_2VAR_2IN_1OUT(uchar2, -) -DECLOP_2VAR_2IN_1OUT(uchar2, *) -DECLOP_2VAR_2IN_1OUT(uchar2, /) -DECLOP_2VAR_2IN_1OUT(uchar2, %) -DECLOP_2VAR_2IN_1OUT(uchar2, &) -DECLOP_2VAR_2IN_1OUT(uchar2, |) -DECLOP_2VAR_2IN_1OUT(uchar2, ^) -DECLOP_2VAR_2IN_1OUT(uchar2, <<) -DECLOP_2VAR_2IN_1OUT(uchar2, >>) - -DECLOP_2VAR_ASSIGN(uchar2, +=) -DECLOP_2VAR_ASSIGN(uchar2, -=) -DECLOP_2VAR_ASSIGN(uchar2, *=) -DECLOP_2VAR_ASSIGN(uchar2, /=) -DECLOP_2VAR_ASSIGN(uchar2, %=) -DECLOP_2VAR_ASSIGN(uchar2, &=) -DECLOP_2VAR_ASSIGN(uchar2, |=) -DECLOP_2VAR_ASSIGN(uchar2, ^=) -DECLOP_2VAR_ASSIGN(uchar2, <<=) -DECLOP_2VAR_ASSIGN(uchar2, >>=) - -DECLOP_2VAR_PREOP(uchar2, ++) -DECLOP_2VAR_PREOP(uchar2, --) - -DECLOP_2VAR_POSTOP(uchar2, ++) -DECLOP_2VAR_POSTOP(uchar2, --) - -DECLOP_2VAR_COMP(uchar2, ==) -DECLOP_2VAR_COMP(uchar2, !=) -DECLOP_2VAR_COMP(uchar2, <) -DECLOP_2VAR_COMP(uchar2, >) -DECLOP_2VAR_COMP(uchar2, <=) -DECLOP_2VAR_COMP(uchar2, >=) - -DECLOP_2VAR_COMP(uchar2, &&) -DECLOP_2VAR_COMP(uchar2, ||) - -DECLOP_2VAR_1IN_1OUT(uchar2, ~) -DECLOP_2VAR_1IN_BOOLOUT(uchar2, !) - -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, float) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, double) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(uchar2, signed long long) - -// UNSIGNED CHAR3 - -DECLOP_3VAR_2IN_1OUT(uchar3, +) -DECLOP_3VAR_2IN_1OUT(uchar3, -) -DECLOP_3VAR_2IN_1OUT(uchar3, *) -DECLOP_3VAR_2IN_1OUT(uchar3, /) -DECLOP_3VAR_2IN_1OUT(uchar3, %) -DECLOP_3VAR_2IN_1OUT(uchar3, &) -DECLOP_3VAR_2IN_1OUT(uchar3, |) -DECLOP_3VAR_2IN_1OUT(uchar3, ^) -DECLOP_3VAR_2IN_1OUT(uchar3, <<) -DECLOP_3VAR_2IN_1OUT(uchar3, >>) - -DECLOP_3VAR_ASSIGN(uchar3, +=) -DECLOP_3VAR_ASSIGN(uchar3, -=) -DECLOP_3VAR_ASSIGN(uchar3, *=) -DECLOP_3VAR_ASSIGN(uchar3, /=) -DECLOP_3VAR_ASSIGN(uchar3, %=) -DECLOP_3VAR_ASSIGN(uchar3, &=) -DECLOP_3VAR_ASSIGN(uchar3, |=) -DECLOP_3VAR_ASSIGN(uchar3, ^=) -DECLOP_3VAR_ASSIGN(uchar3, <<=) -DECLOP_3VAR_ASSIGN(uchar3, >>=) - -DECLOP_3VAR_PREOP(uchar3, ++) -DECLOP_3VAR_PREOP(uchar3, --) - -DECLOP_3VAR_POSTOP(uchar3, ++) -DECLOP_3VAR_POSTOP(uchar3, --) - -DECLOP_3VAR_COMP(uchar3, ==) -DECLOP_3VAR_COMP(uchar3, !=) -DECLOP_3VAR_COMP(uchar3, <) -DECLOP_3VAR_COMP(uchar3, >) -DECLOP_3VAR_COMP(uchar3, <=) -DECLOP_3VAR_COMP(uchar3, >=) - -DECLOP_3VAR_COMP(uchar3, &&) -DECLOP_3VAR_COMP(uchar3, ||) - -DECLOP_3VAR_1IN_1OUT(uchar3, ~) -DECLOP_3VAR_1IN_BOOLOUT(uchar3, !) - -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, float) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, double) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(uchar3, signed long long) - -// UNSIGNED CHAR4 - -DECLOP_4VAR_2IN_1OUT(uchar4, +) -DECLOP_4VAR_2IN_1OUT(uchar4, -) -DECLOP_4VAR_2IN_1OUT(uchar4, *) -DECLOP_4VAR_2IN_1OUT(uchar4, /) -DECLOP_4VAR_2IN_1OUT(uchar4, %) -DECLOP_4VAR_2IN_1OUT(uchar4, &) -DECLOP_4VAR_2IN_1OUT(uchar4, |) -DECLOP_4VAR_2IN_1OUT(uchar4, ^) -DECLOP_4VAR_2IN_1OUT(uchar4, <<) -DECLOP_4VAR_2IN_1OUT(uchar4, >>) - -DECLOP_4VAR_ASSIGN(uchar4, +=) -DECLOP_4VAR_ASSIGN(uchar4, -=) -DECLOP_4VAR_ASSIGN(uchar4, *=) -DECLOP_4VAR_ASSIGN(uchar4, /=) -DECLOP_4VAR_ASSIGN(uchar4, %=) -DECLOP_4VAR_ASSIGN(uchar4, &=) -DECLOP_4VAR_ASSIGN(uchar4, |=) -DECLOP_4VAR_ASSIGN(uchar4, ^=) -DECLOP_4VAR_ASSIGN(uchar4, <<=) -DECLOP_4VAR_ASSIGN(uchar4, >>=) - -DECLOP_4VAR_PREOP(uchar4, ++) -DECLOP_4VAR_PREOP(uchar4, --) - -DECLOP_4VAR_POSTOP(uchar4, ++) -DECLOP_4VAR_POSTOP(uchar4, --) - -DECLOP_4VAR_COMP(uchar4, ==) -DECLOP_4VAR_COMP(uchar4, !=) -DECLOP_4VAR_COMP(uchar4, <) -DECLOP_4VAR_COMP(uchar4, >) -DECLOP_4VAR_COMP(uchar4, <=) -DECLOP_4VAR_COMP(uchar4, >=) - -DECLOP_4VAR_COMP(uchar4, &&) -DECLOP_4VAR_COMP(uchar4, ||) - -DECLOP_4VAR_1IN_1OUT(uchar4, ~) -DECLOP_4VAR_1IN_BOOLOUT(uchar4, !) - -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, float) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, double) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(uchar4, signed long long) - -// SIGNED CHAR1 - -DECLOP_1VAR_2IN_1OUT(char1, +) -DECLOP_1VAR_2IN_1OUT(char1, -) -DECLOP_1VAR_2IN_1OUT(char1, *) -DECLOP_1VAR_2IN_1OUT(char1, /) -DECLOP_1VAR_2IN_1OUT(char1, %) -DECLOP_1VAR_2IN_1OUT(char1, &) -DECLOP_1VAR_2IN_1OUT(char1, |) -DECLOP_1VAR_2IN_1OUT(char1, ^) -DECLOP_1VAR_2IN_1OUT(char1, <<) -DECLOP_1VAR_2IN_1OUT(char1, >>) - - -DECLOP_1VAR_ASSIGN(char1, +=) -DECLOP_1VAR_ASSIGN(char1, -=) -DECLOP_1VAR_ASSIGN(char1, *=) -DECLOP_1VAR_ASSIGN(char1, /=) -DECLOP_1VAR_ASSIGN(char1, %=) -DECLOP_1VAR_ASSIGN(char1, &=) -DECLOP_1VAR_ASSIGN(char1, |=) -DECLOP_1VAR_ASSIGN(char1, ^=) -DECLOP_1VAR_ASSIGN(char1, <<=) -DECLOP_1VAR_ASSIGN(char1, >>=) - -DECLOP_1VAR_PREOP(char1, ++) -DECLOP_1VAR_PREOP(char1, --) - -DECLOP_1VAR_POSTOP(char1, ++) -DECLOP_1VAR_POSTOP(char1, --) - -DECLOP_1VAR_COMP(char1, ==) -DECLOP_1VAR_COMP(char1, !=) -DECLOP_1VAR_COMP(char1, <) -DECLOP_1VAR_COMP(char1, >) -DECLOP_1VAR_COMP(char1, <=) -DECLOP_1VAR_COMP(char1, >=) - -DECLOP_1VAR_COMP(char1, &&) -DECLOP_1VAR_COMP(char1, ||) - -DECLOP_1VAR_1IN_1OUT(char1, ~) -DECLOP_1VAR_1IN_BOOLOUT(char1, !) - -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(char1, float) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(char1, double) -DECLOP_1VAR_SCALE_PRODUCT(char1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(char1, signed long long) - -// SIGNED CHAR2 - -DECLOP_2VAR_2IN_1OUT(char2, +) -DECLOP_2VAR_2IN_1OUT(char2, -) -DECLOP_2VAR_2IN_1OUT(char2, *) -DECLOP_2VAR_2IN_1OUT(char2, /) -DECLOP_2VAR_2IN_1OUT(char2, %) -DECLOP_2VAR_2IN_1OUT(char2, &) -DECLOP_2VAR_2IN_1OUT(char2, |) -DECLOP_2VAR_2IN_1OUT(char2, ^) -DECLOP_2VAR_2IN_1OUT(char2, <<) -DECLOP_2VAR_2IN_1OUT(char2, >>) - -DECLOP_2VAR_ASSIGN(char2, +=) -DECLOP_2VAR_ASSIGN(char2, -=) -DECLOP_2VAR_ASSIGN(char2, *=) -DECLOP_2VAR_ASSIGN(char2, /=) -DECLOP_2VAR_ASSIGN(char2, %=) -DECLOP_2VAR_ASSIGN(char2, &=) -DECLOP_2VAR_ASSIGN(char2, |=) -DECLOP_2VAR_ASSIGN(char2, ^=) -DECLOP_2VAR_ASSIGN(char2, <<=) -DECLOP_2VAR_ASSIGN(char2, >>=) - -DECLOP_2VAR_PREOP(char2, ++) -DECLOP_2VAR_PREOP(char2, --) - -DECLOP_2VAR_POSTOP(char2, ++) -DECLOP_2VAR_POSTOP(char2, --) - -DECLOP_2VAR_COMP(char2, ==) -DECLOP_2VAR_COMP(char2, !=) -DECLOP_2VAR_COMP(char2, <) -DECLOP_2VAR_COMP(char2, >) -DECLOP_2VAR_COMP(char2, <=) -DECLOP_2VAR_COMP(char2, >=) - -DECLOP_2VAR_COMP(char2, &&) -DECLOP_2VAR_COMP(char2, ||) - -DECLOP_2VAR_1IN_1OUT(char2, ~) -DECLOP_2VAR_1IN_BOOLOUT(char2, !) - -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(char2, float) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(char2, double) -DECLOP_2VAR_SCALE_PRODUCT(char2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(char2, signed long long) - -// SIGNED CHAR3 - -DECLOP_3VAR_2IN_1OUT(char3, +) -DECLOP_3VAR_2IN_1OUT(char3, -) -DECLOP_3VAR_2IN_1OUT(char3, *) -DECLOP_3VAR_2IN_1OUT(char3, /) -DECLOP_3VAR_2IN_1OUT(char3, %) -DECLOP_3VAR_2IN_1OUT(char3, &) -DECLOP_3VAR_2IN_1OUT(char3, |) -DECLOP_3VAR_2IN_1OUT(char3, ^) -DECLOP_3VAR_2IN_1OUT(char3, <<) -DECLOP_3VAR_2IN_1OUT(char3, >>) - -DECLOP_3VAR_ASSIGN(char3, +=) -DECLOP_3VAR_ASSIGN(char3, -=) -DECLOP_3VAR_ASSIGN(char3, *=) -DECLOP_3VAR_ASSIGN(char3, /=) -DECLOP_3VAR_ASSIGN(char3, %=) -DECLOP_3VAR_ASSIGN(char3, &=) -DECLOP_3VAR_ASSIGN(char3, |=) -DECLOP_3VAR_ASSIGN(char3, ^=) -DECLOP_3VAR_ASSIGN(char3, <<=) -DECLOP_3VAR_ASSIGN(char3, >>=) - -DECLOP_3VAR_PREOP(char3, ++) -DECLOP_3VAR_PREOP(char3, --) - -DECLOP_3VAR_POSTOP(char3, ++) -DECLOP_3VAR_POSTOP(char3, --) - -DECLOP_3VAR_COMP(char3, ==) -DECLOP_3VAR_COMP(char3, !=) -DECLOP_3VAR_COMP(char3, <) -DECLOP_3VAR_COMP(char3, >) -DECLOP_3VAR_COMP(char3, <=) -DECLOP_3VAR_COMP(char3, >=) - -DECLOP_3VAR_COMP(char3, &&) -DECLOP_3VAR_COMP(char3, ||) - -DECLOP_3VAR_1IN_1OUT(char3, ~) -DECLOP_3VAR_1IN_BOOLOUT(char3, !) - -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(char3, float) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(char3, double) -DECLOP_3VAR_SCALE_PRODUCT(char3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(char3, signed long long) - -// SIGNED CHAR4 - -DECLOP_4VAR_2IN_1OUT(char4, +) -DECLOP_4VAR_2IN_1OUT(char4, -) -DECLOP_4VAR_2IN_1OUT(char4, *) -DECLOP_4VAR_2IN_1OUT(char4, /) -DECLOP_4VAR_2IN_1OUT(char4, %) -DECLOP_4VAR_2IN_1OUT(char4, &) -DECLOP_4VAR_2IN_1OUT(char4, |) -DECLOP_4VAR_2IN_1OUT(char4, ^) -DECLOP_4VAR_2IN_1OUT(char4, <<) -DECLOP_4VAR_2IN_1OUT(char4, >>) - -DECLOP_4VAR_ASSIGN(char4, +=) -DECLOP_4VAR_ASSIGN(char4, -=) -DECLOP_4VAR_ASSIGN(char4, *=) -DECLOP_4VAR_ASSIGN(char4, /=) -DECLOP_4VAR_ASSIGN(char4, %=) -DECLOP_4VAR_ASSIGN(char4, &=) -DECLOP_4VAR_ASSIGN(char4, |=) -DECLOP_4VAR_ASSIGN(char4, ^=) -DECLOP_4VAR_ASSIGN(char4, <<=) -DECLOP_4VAR_ASSIGN(char4, >>=) - -DECLOP_4VAR_PREOP(char4, ++) -DECLOP_4VAR_PREOP(char4, --) - -DECLOP_4VAR_POSTOP(char4, ++) -DECLOP_4VAR_POSTOP(char4, --) - -DECLOP_4VAR_COMP(char4, ==) -DECLOP_4VAR_COMP(char4, !=) -DECLOP_4VAR_COMP(char4, <) -DECLOP_4VAR_COMP(char4, >) -DECLOP_4VAR_COMP(char4, <=) -DECLOP_4VAR_COMP(char4, >=) - -DECLOP_4VAR_COMP(char4, &&) -DECLOP_4VAR_COMP(char4, ||) - -DECLOP_4VAR_1IN_1OUT(char4, ~) -DECLOP_4VAR_1IN_BOOLOUT(char4, !) - -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(char4, float) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(char4, double) -DECLOP_4VAR_SCALE_PRODUCT(char4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(char4, signed long long) - -// UNSIGNED SHORT1 - -DECLOP_1VAR_2IN_1OUT(ushort1, +) -DECLOP_1VAR_2IN_1OUT(ushort1, -) -DECLOP_1VAR_2IN_1OUT(ushort1, *) -DECLOP_1VAR_2IN_1OUT(ushort1, /) -DECLOP_1VAR_2IN_1OUT(ushort1, %) -DECLOP_1VAR_2IN_1OUT(ushort1, &) -DECLOP_1VAR_2IN_1OUT(ushort1, |) -DECLOP_1VAR_2IN_1OUT(ushort1, ^) -DECLOP_1VAR_2IN_1OUT(ushort1, <<) -DECLOP_1VAR_2IN_1OUT(ushort1, >>) - - -DECLOP_1VAR_ASSIGN(ushort1, +=) -DECLOP_1VAR_ASSIGN(ushort1, -=) -DECLOP_1VAR_ASSIGN(ushort1, *=) -DECLOP_1VAR_ASSIGN(ushort1, /=) -DECLOP_1VAR_ASSIGN(ushort1, %=) -DECLOP_1VAR_ASSIGN(ushort1, &=) -DECLOP_1VAR_ASSIGN(ushort1, |=) -DECLOP_1VAR_ASSIGN(ushort1, ^=) -DECLOP_1VAR_ASSIGN(ushort1, <<=) -DECLOP_1VAR_ASSIGN(ushort1, >>=) - -DECLOP_1VAR_PREOP(ushort1, ++) -DECLOP_1VAR_PREOP(ushort1, --) - -DECLOP_1VAR_POSTOP(ushort1, ++) -DECLOP_1VAR_POSTOP(ushort1, --) - -DECLOP_1VAR_COMP(ushort1, ==) -DECLOP_1VAR_COMP(ushort1, !=) -DECLOP_1VAR_COMP(ushort1, <) -DECLOP_1VAR_COMP(ushort1, >) -DECLOP_1VAR_COMP(ushort1, <=) -DECLOP_1VAR_COMP(ushort1, >=) - -DECLOP_1VAR_COMP(ushort1, &&) -DECLOP_1VAR_COMP(ushort1, ||) - -DECLOP_1VAR_1IN_1OUT(ushort1, ~) -DECLOP_1VAR_1IN_BOOLOUT(ushort1, !) - -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, float) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, double) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(ushort1, signed long long) - -// UNSIGNED SHORT2 - -DECLOP_2VAR_2IN_1OUT(ushort2, +) -DECLOP_2VAR_2IN_1OUT(ushort2, -) -DECLOP_2VAR_2IN_1OUT(ushort2, *) -DECLOP_2VAR_2IN_1OUT(ushort2, /) -DECLOP_2VAR_2IN_1OUT(ushort2, %) -DECLOP_2VAR_2IN_1OUT(ushort2, &) -DECLOP_2VAR_2IN_1OUT(ushort2, |) -DECLOP_2VAR_2IN_1OUT(ushort2, ^) -DECLOP_2VAR_2IN_1OUT(ushort2, <<) -DECLOP_2VAR_2IN_1OUT(ushort2, >>) - -DECLOP_2VAR_ASSIGN(ushort2, +=) -DECLOP_2VAR_ASSIGN(ushort2, -=) -DECLOP_2VAR_ASSIGN(ushort2, *=) -DECLOP_2VAR_ASSIGN(ushort2, /=) -DECLOP_2VAR_ASSIGN(ushort2, %=) -DECLOP_2VAR_ASSIGN(ushort2, &=) -DECLOP_2VAR_ASSIGN(ushort2, |=) -DECLOP_2VAR_ASSIGN(ushort2, ^=) -DECLOP_2VAR_ASSIGN(ushort2, <<=) -DECLOP_2VAR_ASSIGN(ushort2, >>=) - -DECLOP_2VAR_PREOP(ushort2, ++) -DECLOP_2VAR_PREOP(ushort2, --) - -DECLOP_2VAR_POSTOP(ushort2, ++) -DECLOP_2VAR_POSTOP(ushort2, --) - -DECLOP_2VAR_COMP(ushort2, ==) -DECLOP_2VAR_COMP(ushort2, !=) -DECLOP_2VAR_COMP(ushort2, <) -DECLOP_2VAR_COMP(ushort2, >) -DECLOP_2VAR_COMP(ushort2, <=) -DECLOP_2VAR_COMP(ushort2, >=) - -DECLOP_2VAR_COMP(ushort2, &&) -DECLOP_2VAR_COMP(ushort2, ||) - -DECLOP_2VAR_1IN_1OUT(ushort2, ~) -DECLOP_2VAR_1IN_BOOLOUT(ushort2, !) - -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, float) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, double) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(ushort2, signed long long) - -// UNSIGNED SHORT3 - -DECLOP_3VAR_2IN_1OUT(ushort3, +) -DECLOP_3VAR_2IN_1OUT(ushort3, -) -DECLOP_3VAR_2IN_1OUT(ushort3, *) -DECLOP_3VAR_2IN_1OUT(ushort3, /) -DECLOP_3VAR_2IN_1OUT(ushort3, %) -DECLOP_3VAR_2IN_1OUT(ushort3, &) -DECLOP_3VAR_2IN_1OUT(ushort3, |) -DECLOP_3VAR_2IN_1OUT(ushort3, ^) -DECLOP_3VAR_2IN_1OUT(ushort3, <<) -DECLOP_3VAR_2IN_1OUT(ushort3, >>) - -DECLOP_3VAR_ASSIGN(ushort3, +=) -DECLOP_3VAR_ASSIGN(ushort3, -=) -DECLOP_3VAR_ASSIGN(ushort3, *=) -DECLOP_3VAR_ASSIGN(ushort3, /=) -DECLOP_3VAR_ASSIGN(ushort3, %=) -DECLOP_3VAR_ASSIGN(ushort3, &=) -DECLOP_3VAR_ASSIGN(ushort3, |=) -DECLOP_3VAR_ASSIGN(ushort3, ^=) -DECLOP_3VAR_ASSIGN(ushort3, <<=) -DECLOP_3VAR_ASSIGN(ushort3, >>=) - -DECLOP_3VAR_PREOP(ushort3, ++) -DECLOP_3VAR_PREOP(ushort3, --) - -DECLOP_3VAR_POSTOP(ushort3, ++) -DECLOP_3VAR_POSTOP(ushort3, --) - -DECLOP_3VAR_COMP(ushort3, ==) -DECLOP_3VAR_COMP(ushort3, !=) -DECLOP_3VAR_COMP(ushort3, <) -DECLOP_3VAR_COMP(ushort3, >) -DECLOP_3VAR_COMP(ushort3, <=) -DECLOP_3VAR_COMP(ushort3, >=) - -DECLOP_3VAR_COMP(ushort3, &&) -DECLOP_3VAR_COMP(ushort3, ||) - -DECLOP_3VAR_1IN_1OUT(ushort3, ~) -DECLOP_3VAR_1IN_BOOLOUT(ushort3, !) - -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, float) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, double) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(ushort3, signed long long) - -// UNSIGNED SHORT4 - -DECLOP_4VAR_2IN_1OUT(ushort4, +) -DECLOP_4VAR_2IN_1OUT(ushort4, -) -DECLOP_4VAR_2IN_1OUT(ushort4, *) -DECLOP_4VAR_2IN_1OUT(ushort4, /) -DECLOP_4VAR_2IN_1OUT(ushort4, %) -DECLOP_4VAR_2IN_1OUT(ushort4, &) -DECLOP_4VAR_2IN_1OUT(ushort4, |) -DECLOP_4VAR_2IN_1OUT(ushort4, ^) -DECLOP_4VAR_2IN_1OUT(ushort4, <<) -DECLOP_4VAR_2IN_1OUT(ushort4, >>) - -DECLOP_4VAR_ASSIGN(ushort4, +=) -DECLOP_4VAR_ASSIGN(ushort4, -=) -DECLOP_4VAR_ASSIGN(ushort4, *=) -DECLOP_4VAR_ASSIGN(ushort4, /=) -DECLOP_4VAR_ASSIGN(ushort4, %=) -DECLOP_4VAR_ASSIGN(ushort4, &=) -DECLOP_4VAR_ASSIGN(ushort4, |=) -DECLOP_4VAR_ASSIGN(ushort4, ^=) -DECLOP_4VAR_ASSIGN(ushort4, <<=) -DECLOP_4VAR_ASSIGN(ushort4, >>=) - -DECLOP_4VAR_PREOP(ushort4, ++) -DECLOP_4VAR_PREOP(ushort4, --) - -DECLOP_4VAR_POSTOP(ushort4, ++) -DECLOP_4VAR_POSTOP(ushort4, --) - -DECLOP_4VAR_COMP(ushort4, ==) -DECLOP_4VAR_COMP(ushort4, !=) -DECLOP_4VAR_COMP(ushort4, <) -DECLOP_4VAR_COMP(ushort4, >) -DECLOP_4VAR_COMP(ushort4, <=) -DECLOP_4VAR_COMP(ushort4, >=) - -DECLOP_4VAR_COMP(ushort4, &&) -DECLOP_4VAR_COMP(ushort4, ||) - -DECLOP_4VAR_1IN_1OUT(ushort4, ~) -DECLOP_4VAR_1IN_BOOLOUT(ushort4, !) - -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, float) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, double) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(ushort4, signed long long) - -// SIGNED SHORT1 - -DECLOP_1VAR_2IN_1OUT(short1, +) -DECLOP_1VAR_2IN_1OUT(short1, -) -DECLOP_1VAR_2IN_1OUT(short1, *) -DECLOP_1VAR_2IN_1OUT(short1, /) -DECLOP_1VAR_2IN_1OUT(short1, %) -DECLOP_1VAR_2IN_1OUT(short1, &) -DECLOP_1VAR_2IN_1OUT(short1, |) -DECLOP_1VAR_2IN_1OUT(short1, ^) -DECLOP_1VAR_2IN_1OUT(short1, <<) -DECLOP_1VAR_2IN_1OUT(short1, >>) - - -DECLOP_1VAR_ASSIGN(short1, +=) -DECLOP_1VAR_ASSIGN(short1, -=) -DECLOP_1VAR_ASSIGN(short1, *=) -DECLOP_1VAR_ASSIGN(short1, /=) -DECLOP_1VAR_ASSIGN(short1, %=) -DECLOP_1VAR_ASSIGN(short1, &=) -DECLOP_1VAR_ASSIGN(short1, |=) -DECLOP_1VAR_ASSIGN(short1, ^=) -DECLOP_1VAR_ASSIGN(short1, <<=) -DECLOP_1VAR_ASSIGN(short1, >>=) - -DECLOP_1VAR_PREOP(short1, ++) -DECLOP_1VAR_PREOP(short1, --) - -DECLOP_1VAR_POSTOP(short1, ++) -DECLOP_1VAR_POSTOP(short1, --) - -DECLOP_1VAR_COMP(short1, ==) -DECLOP_1VAR_COMP(short1, !=) -DECLOP_1VAR_COMP(short1, <) -DECLOP_1VAR_COMP(short1, >) -DECLOP_1VAR_COMP(short1, <=) -DECLOP_1VAR_COMP(short1, >=) - -DECLOP_1VAR_COMP(short1, &&) -DECLOP_1VAR_COMP(short1, ||) - -DECLOP_1VAR_1IN_1OUT(short1, ~) -DECLOP_1VAR_1IN_BOOLOUT(short1, !) - -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(short1, float) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(short1, double) -DECLOP_1VAR_SCALE_PRODUCT(short1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(short1, signed long long) - -// SIGNED SHORT2 - -DECLOP_2VAR_2IN_1OUT(short2, +) -DECLOP_2VAR_2IN_1OUT(short2, -) -DECLOP_2VAR_2IN_1OUT(short2, *) -DECLOP_2VAR_2IN_1OUT(short2, /) -DECLOP_2VAR_2IN_1OUT(short2, %) -DECLOP_2VAR_2IN_1OUT(short2, &) -DECLOP_2VAR_2IN_1OUT(short2, |) -DECLOP_2VAR_2IN_1OUT(short2, ^) -DECLOP_2VAR_2IN_1OUT(short2, <<) -DECLOP_2VAR_2IN_1OUT(short2, >>) - -DECLOP_2VAR_ASSIGN(short2, +=) -DECLOP_2VAR_ASSIGN(short2, -=) -DECLOP_2VAR_ASSIGN(short2, *=) -DECLOP_2VAR_ASSIGN(short2, /=) -DECLOP_2VAR_ASSIGN(short2, %=) -DECLOP_2VAR_ASSIGN(short2, &=) -DECLOP_2VAR_ASSIGN(short2, |=) -DECLOP_2VAR_ASSIGN(short2, ^=) -DECLOP_2VAR_ASSIGN(short2, <<=) -DECLOP_2VAR_ASSIGN(short2, >>=) - -DECLOP_2VAR_PREOP(short2, ++) -DECLOP_2VAR_PREOP(short2, --) - -DECLOP_2VAR_POSTOP(short2, ++) -DECLOP_2VAR_POSTOP(short2, --) - -DECLOP_2VAR_COMP(short2, ==) -DECLOP_2VAR_COMP(short2, !=) -DECLOP_2VAR_COMP(short2, <) -DECLOP_2VAR_COMP(short2, >) -DECLOP_2VAR_COMP(short2, <=) -DECLOP_2VAR_COMP(short2, >=) - -DECLOP_2VAR_COMP(short2, &&) -DECLOP_2VAR_COMP(short2, ||) - -DECLOP_2VAR_1IN_1OUT(short2, ~) -DECLOP_2VAR_1IN_BOOLOUT(short2, !) - -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(short2, float) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(short2, double) -DECLOP_2VAR_SCALE_PRODUCT(short2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(short2, signed long long) - -// SIGNED SHORT3 - -DECLOP_3VAR_2IN_1OUT(short3, +) -DECLOP_3VAR_2IN_1OUT(short3, -) -DECLOP_3VAR_2IN_1OUT(short3, *) -DECLOP_3VAR_2IN_1OUT(short3, /) -DECLOP_3VAR_2IN_1OUT(short3, %) -DECLOP_3VAR_2IN_1OUT(short3, &) -DECLOP_3VAR_2IN_1OUT(short3, |) -DECLOP_3VAR_2IN_1OUT(short3, ^) -DECLOP_3VAR_2IN_1OUT(short3, <<) -DECLOP_3VAR_2IN_1OUT(short3, >>) - -DECLOP_3VAR_ASSIGN(short3, +=) -DECLOP_3VAR_ASSIGN(short3, -=) -DECLOP_3VAR_ASSIGN(short3, *=) -DECLOP_3VAR_ASSIGN(short3, /=) -DECLOP_3VAR_ASSIGN(short3, %=) -DECLOP_3VAR_ASSIGN(short3, &=) -DECLOP_3VAR_ASSIGN(short3, |=) -DECLOP_3VAR_ASSIGN(short3, ^=) -DECLOP_3VAR_ASSIGN(short3, <<=) -DECLOP_3VAR_ASSIGN(short3, >>=) - -DECLOP_3VAR_PREOP(short3, ++) -DECLOP_3VAR_PREOP(short3, --) - -DECLOP_3VAR_POSTOP(short3, ++) -DECLOP_3VAR_POSTOP(short3, --) - -DECLOP_3VAR_COMP(short3, ==) -DECLOP_3VAR_COMP(short3, !=) -DECLOP_3VAR_COMP(short3, <) -DECLOP_3VAR_COMP(short3, >) -DECLOP_3VAR_COMP(short3, <=) -DECLOP_3VAR_COMP(short3, >=) - -DECLOP_3VAR_COMP(short3, &&) -DECLOP_3VAR_COMP(short3, ||) - -DECLOP_3VAR_1IN_1OUT(short3, ~) -DECLOP_3VAR_1IN_BOOLOUT(short3, !) - -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(short3, float) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(short3, double) -DECLOP_3VAR_SCALE_PRODUCT(short3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(short3, signed long long) - -// SIGNED SHORT4 - -DECLOP_4VAR_2IN_1OUT(short4, +) -DECLOP_4VAR_2IN_1OUT(short4, -) -DECLOP_4VAR_2IN_1OUT(short4, *) -DECLOP_4VAR_2IN_1OUT(short4, /) -DECLOP_4VAR_2IN_1OUT(short4, %) -DECLOP_4VAR_2IN_1OUT(short4, &) -DECLOP_4VAR_2IN_1OUT(short4, |) -DECLOP_4VAR_2IN_1OUT(short4, ^) -DECLOP_4VAR_2IN_1OUT(short4, <<) -DECLOP_4VAR_2IN_1OUT(short4, >>) - -DECLOP_4VAR_ASSIGN(short4, +=) -DECLOP_4VAR_ASSIGN(short4, -=) -DECLOP_4VAR_ASSIGN(short4, *=) -DECLOP_4VAR_ASSIGN(short4, /=) -DECLOP_4VAR_ASSIGN(short4, %=) -DECLOP_4VAR_ASSIGN(short4, &=) -DECLOP_4VAR_ASSIGN(short4, |=) -DECLOP_4VAR_ASSIGN(short4, ^=) -DECLOP_4VAR_ASSIGN(short4, <<=) -DECLOP_4VAR_ASSIGN(short4, >>=) - -DECLOP_4VAR_PREOP(short4, ++) -DECLOP_4VAR_PREOP(short4, --) - -DECLOP_4VAR_POSTOP(short4, ++) -DECLOP_4VAR_POSTOP(short4, --) - -DECLOP_4VAR_COMP(short4, ==) -DECLOP_4VAR_COMP(short4, !=) -DECLOP_4VAR_COMP(short4, <) -DECLOP_4VAR_COMP(short4, >) -DECLOP_4VAR_COMP(short4, <=) -DECLOP_4VAR_COMP(short4, >=) - -DECLOP_4VAR_COMP(short4, &&) -DECLOP_4VAR_COMP(short4, ||) - -DECLOP_4VAR_1IN_1OUT(short4, ~) -DECLOP_4VAR_1IN_BOOLOUT(short4, !) - -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(short4, float) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(short4, double) -DECLOP_4VAR_SCALE_PRODUCT(short4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(short4, signed long long) - -// UNSIGNED INT1 - -DECLOP_1VAR_2IN_1OUT(uint1, +) -DECLOP_1VAR_2IN_1OUT(uint1, -) -DECLOP_1VAR_2IN_1OUT(uint1, *) -DECLOP_1VAR_2IN_1OUT(uint1, /) -DECLOP_1VAR_2IN_1OUT(uint1, %) -DECLOP_1VAR_2IN_1OUT(uint1, &) -DECLOP_1VAR_2IN_1OUT(uint1, |) -DECLOP_1VAR_2IN_1OUT(uint1, ^) -DECLOP_1VAR_2IN_1OUT(uint1, <<) -DECLOP_1VAR_2IN_1OUT(uint1, >>) - - -DECLOP_1VAR_ASSIGN(uint1, +=) -DECLOP_1VAR_ASSIGN(uint1, -=) -DECLOP_1VAR_ASSIGN(uint1, *=) -DECLOP_1VAR_ASSIGN(uint1, /=) -DECLOP_1VAR_ASSIGN(uint1, %=) -DECLOP_1VAR_ASSIGN(uint1, &=) -DECLOP_1VAR_ASSIGN(uint1, |=) -DECLOP_1VAR_ASSIGN(uint1, ^=) -DECLOP_1VAR_ASSIGN(uint1, <<=) -DECLOP_1VAR_ASSIGN(uint1, >>=) - -DECLOP_1VAR_PREOP(uint1, ++) -DECLOP_1VAR_PREOP(uint1, --) - -DECLOP_1VAR_POSTOP(uint1, ++) -DECLOP_1VAR_POSTOP(uint1, --) - -DECLOP_1VAR_COMP(uint1, ==) -DECLOP_1VAR_COMP(uint1, !=) -DECLOP_1VAR_COMP(uint1, <) -DECLOP_1VAR_COMP(uint1, >) -DECLOP_1VAR_COMP(uint1, <=) -DECLOP_1VAR_COMP(uint1, >=) - -DECLOP_1VAR_COMP(uint1, &&) -DECLOP_1VAR_COMP(uint1, ||) - -DECLOP_1VAR_1IN_1OUT(uint1, ~) -DECLOP_1VAR_1IN_BOOLOUT(uint1, !) - -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(uint1, float) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(uint1, double) -DECLOP_1VAR_SCALE_PRODUCT(uint1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(uint1, signed long long) - -// UNSIGNED INT2 - -DECLOP_2VAR_2IN_1OUT(uint2, +) -DECLOP_2VAR_2IN_1OUT(uint2, -) -DECLOP_2VAR_2IN_1OUT(uint2, *) -DECLOP_2VAR_2IN_1OUT(uint2, /) -DECLOP_2VAR_2IN_1OUT(uint2, %) -DECLOP_2VAR_2IN_1OUT(uint2, &) -DECLOP_2VAR_2IN_1OUT(uint2, |) -DECLOP_2VAR_2IN_1OUT(uint2, ^) -DECLOP_2VAR_2IN_1OUT(uint2, <<) -DECLOP_2VAR_2IN_1OUT(uint2, >>) - -DECLOP_2VAR_ASSIGN(uint2, +=) -DECLOP_2VAR_ASSIGN(uint2, -=) -DECLOP_2VAR_ASSIGN(uint2, *=) -DECLOP_2VAR_ASSIGN(uint2, /=) -DECLOP_2VAR_ASSIGN(uint2, %=) -DECLOP_2VAR_ASSIGN(uint2, &=) -DECLOP_2VAR_ASSIGN(uint2, |=) -DECLOP_2VAR_ASSIGN(uint2, ^=) -DECLOP_2VAR_ASSIGN(uint2, <<=) -DECLOP_2VAR_ASSIGN(uint2, >>=) - -DECLOP_2VAR_PREOP(uint2, ++) -DECLOP_2VAR_PREOP(uint2, --) - -DECLOP_2VAR_POSTOP(uint2, ++) -DECLOP_2VAR_POSTOP(uint2, --) - -DECLOP_2VAR_COMP(uint2, ==) -DECLOP_2VAR_COMP(uint2, !=) -DECLOP_2VAR_COMP(uint2, <) -DECLOP_2VAR_COMP(uint2, >) -DECLOP_2VAR_COMP(uint2, <=) -DECLOP_2VAR_COMP(uint2, >=) - -DECLOP_2VAR_COMP(uint2, &&) -DECLOP_2VAR_COMP(uint2, ||) - -DECLOP_2VAR_1IN_1OUT(uint2, ~) -DECLOP_2VAR_1IN_BOOLOUT(uint2, !) - -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(uint2, float) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(uint2, double) -DECLOP_2VAR_SCALE_PRODUCT(uint2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(uint2, signed long long) - -// UNSIGNED INT3 - -DECLOP_3VAR_2IN_1OUT(uint3, +) -DECLOP_3VAR_2IN_1OUT(uint3, -) -DECLOP_3VAR_2IN_1OUT(uint3, *) -DECLOP_3VAR_2IN_1OUT(uint3, /) -DECLOP_3VAR_2IN_1OUT(uint3, %) -DECLOP_3VAR_2IN_1OUT(uint3, &) -DECLOP_3VAR_2IN_1OUT(uint3, |) -DECLOP_3VAR_2IN_1OUT(uint3, ^) -DECLOP_3VAR_2IN_1OUT(uint3, <<) -DECLOP_3VAR_2IN_1OUT(uint3, >>) - -DECLOP_3VAR_ASSIGN(uint3, +=) -DECLOP_3VAR_ASSIGN(uint3, -=) -DECLOP_3VAR_ASSIGN(uint3, *=) -DECLOP_3VAR_ASSIGN(uint3, /=) -DECLOP_3VAR_ASSIGN(uint3, %=) -DECLOP_3VAR_ASSIGN(uint3, &=) -DECLOP_3VAR_ASSIGN(uint3, |=) -DECLOP_3VAR_ASSIGN(uint3, ^=) -DECLOP_3VAR_ASSIGN(uint3, <<=) -DECLOP_3VAR_ASSIGN(uint3, >>=) - -DECLOP_3VAR_PREOP(uint3, ++) -DECLOP_3VAR_PREOP(uint3, --) - -DECLOP_3VAR_POSTOP(uint3, ++) -DECLOP_3VAR_POSTOP(uint3, --) - -DECLOP_3VAR_COMP(uint3, ==) -DECLOP_3VAR_COMP(uint3, !=) -DECLOP_3VAR_COMP(uint3, <) -DECLOP_3VAR_COMP(uint3, >) -DECLOP_3VAR_COMP(uint3, <=) -DECLOP_3VAR_COMP(uint3, >=) - -DECLOP_3VAR_COMP(uint3, &&) -DECLOP_3VAR_COMP(uint3, ||) - -DECLOP_3VAR_1IN_1OUT(uint3, ~) -DECLOP_3VAR_1IN_BOOLOUT(uint3, !) - -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(uint3, float) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(uint3, double) -DECLOP_3VAR_SCALE_PRODUCT(uint3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(uint3, signed long long) - -// UNSIGNED INT4 - -DECLOP_4VAR_2IN_1OUT(uint4, +) -DECLOP_4VAR_2IN_1OUT(uint4, -) -DECLOP_4VAR_2IN_1OUT(uint4, *) -DECLOP_4VAR_2IN_1OUT(uint4, /) -DECLOP_4VAR_2IN_1OUT(uint4, %) -DECLOP_4VAR_2IN_1OUT(uint4, &) -DECLOP_4VAR_2IN_1OUT(uint4, |) -DECLOP_4VAR_2IN_1OUT(uint4, ^) -DECLOP_4VAR_2IN_1OUT(uint4, <<) -DECLOP_4VAR_2IN_1OUT(uint4, >>) - -DECLOP_4VAR_ASSIGN(uint4, +=) -DECLOP_4VAR_ASSIGN(uint4, -=) -DECLOP_4VAR_ASSIGN(uint4, *=) -DECLOP_4VAR_ASSIGN(uint4, /=) -DECLOP_4VAR_ASSIGN(uint4, %=) -DECLOP_4VAR_ASSIGN(uint4, &=) -DECLOP_4VAR_ASSIGN(uint4, |=) -DECLOP_4VAR_ASSIGN(uint4, ^=) -DECLOP_4VAR_ASSIGN(uint4, <<=) -DECLOP_4VAR_ASSIGN(uint4, >>=) - -DECLOP_4VAR_PREOP(uint4, ++) -DECLOP_4VAR_PREOP(uint4, --) - -DECLOP_4VAR_POSTOP(uint4, ++) -DECLOP_4VAR_POSTOP(uint4, --) - -DECLOP_4VAR_COMP(uint4, ==) -DECLOP_4VAR_COMP(uint4, !=) -DECLOP_4VAR_COMP(uint4, <) -DECLOP_4VAR_COMP(uint4, >) -DECLOP_4VAR_COMP(uint4, <=) -DECLOP_4VAR_COMP(uint4, >=) - -DECLOP_4VAR_COMP(uint4, &&) -DECLOP_4VAR_COMP(uint4, ||) - -DECLOP_4VAR_1IN_1OUT(uint4, ~) -DECLOP_4VAR_1IN_BOOLOUT(uint4, !) - -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(uint4, float) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(uint4, double) -DECLOP_4VAR_SCALE_PRODUCT(uint4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(uint4, signed long long) - -// SIGNED INT1 - -DECLOP_1VAR_2IN_1OUT(int1, +) -DECLOP_1VAR_2IN_1OUT(int1, -) -DECLOP_1VAR_2IN_1OUT(int1, *) -DECLOP_1VAR_2IN_1OUT(int1, /) -DECLOP_1VAR_2IN_1OUT(int1, %) -DECLOP_1VAR_2IN_1OUT(int1, &) -DECLOP_1VAR_2IN_1OUT(int1, |) -DECLOP_1VAR_2IN_1OUT(int1, ^) -DECLOP_1VAR_2IN_1OUT(int1, <<) -DECLOP_1VAR_2IN_1OUT(int1, >>) - - -DECLOP_1VAR_ASSIGN(int1, +=) -DECLOP_1VAR_ASSIGN(int1, -=) -DECLOP_1VAR_ASSIGN(int1, *=) -DECLOP_1VAR_ASSIGN(int1, /=) -DECLOP_1VAR_ASSIGN(int1, %=) -DECLOP_1VAR_ASSIGN(int1, &=) -DECLOP_1VAR_ASSIGN(int1, |=) -DECLOP_1VAR_ASSIGN(int1, ^=) -DECLOP_1VAR_ASSIGN(int1, <<=) -DECLOP_1VAR_ASSIGN(int1, >>=) - -DECLOP_1VAR_PREOP(int1, ++) -DECLOP_1VAR_PREOP(int1, --) - -DECLOP_1VAR_POSTOP(int1, ++) -DECLOP_1VAR_POSTOP(int1, --) - -DECLOP_1VAR_COMP(int1, ==) -DECLOP_1VAR_COMP(int1, !=) -DECLOP_1VAR_COMP(int1, <) -DECLOP_1VAR_COMP(int1, >) -DECLOP_1VAR_COMP(int1, <=) -DECLOP_1VAR_COMP(int1, >=) - -DECLOP_1VAR_COMP(int1, &&) -DECLOP_1VAR_COMP(int1, ||) - -DECLOP_1VAR_1IN_1OUT(int1, ~) -DECLOP_1VAR_1IN_BOOLOUT(int1, !) - -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(int1, float) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(int1, double) -DECLOP_1VAR_SCALE_PRODUCT(int1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(int1, signed long long) - -// SIGNED INT2 - -DECLOP_2VAR_2IN_1OUT(int2, +) -DECLOP_2VAR_2IN_1OUT(int2, -) -DECLOP_2VAR_2IN_1OUT(int2, *) -DECLOP_2VAR_2IN_1OUT(int2, /) -DECLOP_2VAR_2IN_1OUT(int2, %) -DECLOP_2VAR_2IN_1OUT(int2, &) -DECLOP_2VAR_2IN_1OUT(int2, |) -DECLOP_2VAR_2IN_1OUT(int2, ^) -DECLOP_2VAR_2IN_1OUT(int2, <<) -DECLOP_2VAR_2IN_1OUT(int2, >>) - -DECLOP_2VAR_ASSIGN(int2, +=) -DECLOP_2VAR_ASSIGN(int2, -=) -DECLOP_2VAR_ASSIGN(int2, *=) -DECLOP_2VAR_ASSIGN(int2, /=) -DECLOP_2VAR_ASSIGN(int2, %=) -DECLOP_2VAR_ASSIGN(int2, &=) -DECLOP_2VAR_ASSIGN(int2, |=) -DECLOP_2VAR_ASSIGN(int2, ^=) -DECLOP_2VAR_ASSIGN(int2, <<=) -DECLOP_2VAR_ASSIGN(int2, >>=) - -DECLOP_2VAR_PREOP(int2, ++) -DECLOP_2VAR_PREOP(int2, --) - -DECLOP_2VAR_POSTOP(int2, ++) -DECLOP_2VAR_POSTOP(int2, --) - -DECLOP_2VAR_COMP(int2, ==) -DECLOP_2VAR_COMP(int2, !=) -DECLOP_2VAR_COMP(int2, <) -DECLOP_2VAR_COMP(int2, >) -DECLOP_2VAR_COMP(int2, <=) -DECLOP_2VAR_COMP(int2, >=) - -DECLOP_2VAR_COMP(int2, &&) -DECLOP_2VAR_COMP(int2, ||) - -DECLOP_2VAR_1IN_1OUT(int2, ~) -DECLOP_2VAR_1IN_BOOLOUT(int2, !) - -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(int2, float) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(int2, double) -DECLOP_2VAR_SCALE_PRODUCT(int2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(int2, signed long long) - -// SIGNED INT3 - -DECLOP_3VAR_2IN_1OUT(int3, +) -DECLOP_3VAR_2IN_1OUT(int3, -) -DECLOP_3VAR_2IN_1OUT(int3, *) -DECLOP_3VAR_2IN_1OUT(int3, /) -DECLOP_3VAR_2IN_1OUT(int3, %) -DECLOP_3VAR_2IN_1OUT(int3, &) -DECLOP_3VAR_2IN_1OUT(int3, |) -DECLOP_3VAR_2IN_1OUT(int3, ^) -DECLOP_3VAR_2IN_1OUT(int3, <<) -DECLOP_3VAR_2IN_1OUT(int3, >>) - -DECLOP_3VAR_ASSIGN(int3, +=) -DECLOP_3VAR_ASSIGN(int3, -=) -DECLOP_3VAR_ASSIGN(int3, *=) -DECLOP_3VAR_ASSIGN(int3, /=) -DECLOP_3VAR_ASSIGN(int3, %=) -DECLOP_3VAR_ASSIGN(int3, &=) -DECLOP_3VAR_ASSIGN(int3, |=) -DECLOP_3VAR_ASSIGN(int3, ^=) -DECLOP_3VAR_ASSIGN(int3, <<=) -DECLOP_3VAR_ASSIGN(int3, >>=) - -DECLOP_3VAR_PREOP(int3, ++) -DECLOP_3VAR_PREOP(int3, --) - -DECLOP_3VAR_POSTOP(int3, ++) -DECLOP_3VAR_POSTOP(int3, --) - -DECLOP_3VAR_COMP(int3, ==) -DECLOP_3VAR_COMP(int3, !=) -DECLOP_3VAR_COMP(int3, <) -DECLOP_3VAR_COMP(int3, >) -DECLOP_3VAR_COMP(int3, <=) -DECLOP_3VAR_COMP(int3, >=) - -DECLOP_3VAR_COMP(int3, &&) -DECLOP_3VAR_COMP(int3, ||) - -DECLOP_3VAR_1IN_1OUT(int3, ~) -DECLOP_3VAR_1IN_BOOLOUT(int3, !) - -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(int3, float) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(int3, double) -DECLOP_3VAR_SCALE_PRODUCT(int3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(int3, signed long long) - -// SIGNED INT4 - -DECLOP_4VAR_2IN_1OUT(int4, +) -DECLOP_4VAR_2IN_1OUT(int4, -) -DECLOP_4VAR_2IN_1OUT(int4, *) -DECLOP_4VAR_2IN_1OUT(int4, /) -DECLOP_4VAR_2IN_1OUT(int4, %) -DECLOP_4VAR_2IN_1OUT(int4, &) -DECLOP_4VAR_2IN_1OUT(int4, |) -DECLOP_4VAR_2IN_1OUT(int4, ^) -DECLOP_4VAR_2IN_1OUT(int4, <<) -DECLOP_4VAR_2IN_1OUT(int4, >>) - -DECLOP_4VAR_ASSIGN(int4, +=) -DECLOP_4VAR_ASSIGN(int4, -=) -DECLOP_4VAR_ASSIGN(int4, *=) -DECLOP_4VAR_ASSIGN(int4, /=) -DECLOP_4VAR_ASSIGN(int4, %=) -DECLOP_4VAR_ASSIGN(int4, &=) -DECLOP_4VAR_ASSIGN(int4, |=) -DECLOP_4VAR_ASSIGN(int4, ^=) -DECLOP_4VAR_ASSIGN(int4, <<=) -DECLOP_4VAR_ASSIGN(int4, >>=) - -DECLOP_4VAR_PREOP(int4, ++) -DECLOP_4VAR_PREOP(int4, --) - -DECLOP_4VAR_POSTOP(int4, ++) -DECLOP_4VAR_POSTOP(int4, --) - -DECLOP_4VAR_COMP(int4, ==) -DECLOP_4VAR_COMP(int4, !=) -DECLOP_4VAR_COMP(int4, <) -DECLOP_4VAR_COMP(int4, >) -DECLOP_4VAR_COMP(int4, <=) -DECLOP_4VAR_COMP(int4, >=) - -DECLOP_4VAR_COMP(int4, &&) -DECLOP_4VAR_COMP(int4, ||) - -DECLOP_4VAR_1IN_1OUT(int4, ~) -DECLOP_4VAR_1IN_BOOLOUT(int4, !) - -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(int4, float) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(int4, double) -DECLOP_4VAR_SCALE_PRODUCT(int4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(int4, signed long long) - -// FLOAT1 - -DECLOP_1VAR_2IN_1OUT(float1, +) -DECLOP_1VAR_2IN_1OUT(float1, -) -DECLOP_1VAR_2IN_1OUT(float1, *) -DECLOP_1VAR_2IN_1OUT(float1, /) - -DECLOP_1VAR_ASSIGN(float1, +=) -DECLOP_1VAR_ASSIGN(float1, -=) -DECLOP_1VAR_ASSIGN(float1, *=) -DECLOP_1VAR_ASSIGN(float1, /=) - -DECLOP_1VAR_PREOP(float1, ++) -DECLOP_1VAR_PREOP(float1, --) - -DECLOP_1VAR_POSTOP(float1, ++) -DECLOP_1VAR_POSTOP(float1, --) - -DECLOP_1VAR_COMP(float1, ==) -DECLOP_1VAR_COMP(float1, !=) -DECLOP_1VAR_COMP(float1, <) -DECLOP_1VAR_COMP(float1, >) -DECLOP_1VAR_COMP(float1, <=) -DECLOP_1VAR_COMP(float1, >=) - -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(float1, float) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(float1, double) -DECLOP_1VAR_SCALE_PRODUCT(float1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(float1, signed long long) - -// FLOAT2 - -DECLOP_2VAR_2IN_1OUT(float2, +) -DECLOP_2VAR_2IN_1OUT(float2, -) -DECLOP_2VAR_2IN_1OUT(float2, *) -DECLOP_2VAR_2IN_1OUT(float2, /) - -DECLOP_2VAR_ASSIGN(float2, +=) -DECLOP_2VAR_ASSIGN(float2, -=) -DECLOP_2VAR_ASSIGN(float2, *=) -DECLOP_2VAR_ASSIGN(float2, /=) - -DECLOP_2VAR_PREOP(float2, ++) -DECLOP_2VAR_PREOP(float2, --) - -DECLOP_2VAR_POSTOP(float2, ++) -DECLOP_2VAR_POSTOP(float2, --) - -DECLOP_2VAR_COMP(float2, ==) -DECLOP_2VAR_COMP(float2, !=) -DECLOP_2VAR_COMP(float2, <) -DECLOP_2VAR_COMP(float2, >) -DECLOP_2VAR_COMP(float2, <=) -DECLOP_2VAR_COMP(float2, >=) - -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(float2, float) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(float2, double) -DECLOP_2VAR_SCALE_PRODUCT(float2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(float2, signed long long) - -// FLOAT3 - -DECLOP_3VAR_2IN_1OUT(float3, +) -DECLOP_3VAR_2IN_1OUT(float3, -) -DECLOP_3VAR_2IN_1OUT(float3, *) -DECLOP_3VAR_2IN_1OUT(float3, /) - -DECLOP_3VAR_ASSIGN(float3, +=) -DECLOP_3VAR_ASSIGN(float3, -=) -DECLOP_3VAR_ASSIGN(float3, *=) -DECLOP_3VAR_ASSIGN(float3, /=) - -DECLOP_3VAR_PREOP(float3, ++) -DECLOP_3VAR_PREOP(float3, --) - -DECLOP_3VAR_POSTOP(float3, ++) -DECLOP_3VAR_POSTOP(float3, --) - -DECLOP_3VAR_COMP(float3, ==) -DECLOP_3VAR_COMP(float3, !=) -DECLOP_3VAR_COMP(float3, <) -DECLOP_3VAR_COMP(float3, >) -DECLOP_3VAR_COMP(float3, <=) -DECLOP_3VAR_COMP(float3, >=) - -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(float3, float) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(float3, double) -DECLOP_3VAR_SCALE_PRODUCT(float3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(float3, signed long long) - -// FLOAT4 - -DECLOP_4VAR_2IN_1OUT(float4, +) -DECLOP_4VAR_2IN_1OUT(float4, -) -DECLOP_4VAR_2IN_1OUT(float4, *) -DECLOP_4VAR_2IN_1OUT(float4, /) - -DECLOP_4VAR_ASSIGN(float4, +=) -DECLOP_4VAR_ASSIGN(float4, -=) -DECLOP_4VAR_ASSIGN(float4, *=) -DECLOP_4VAR_ASSIGN(float4, /=) - -DECLOP_4VAR_PREOP(float4, ++) -DECLOP_4VAR_PREOP(float4, --) - -DECLOP_4VAR_POSTOP(float4, ++) -DECLOP_4VAR_POSTOP(float4, --) - -DECLOP_4VAR_COMP(float4, ==) -DECLOP_4VAR_COMP(float4, !=) -DECLOP_4VAR_COMP(float4, <) -DECLOP_4VAR_COMP(float4, >) -DECLOP_4VAR_COMP(float4, <=) -DECLOP_4VAR_COMP(float4, >=) - -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(float4, float) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(float4, double) -DECLOP_4VAR_SCALE_PRODUCT(float4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(float4, signed long long) - -// DOUBLE1 - -DECLOP_1VAR_2IN_1OUT(double1, +) -DECLOP_1VAR_2IN_1OUT(double1, -) -DECLOP_1VAR_2IN_1OUT(double1, *) -DECLOP_1VAR_2IN_1OUT(double1, /) - -DECLOP_1VAR_ASSIGN(double1, +=) -DECLOP_1VAR_ASSIGN(double1, -=) -DECLOP_1VAR_ASSIGN(double1, *=) -DECLOP_1VAR_ASSIGN(double1, /=) - -DECLOP_1VAR_PREOP(double1, ++) -DECLOP_1VAR_PREOP(double1, --) - -DECLOP_1VAR_POSTOP(double1, ++) -DECLOP_1VAR_POSTOP(double1, --) - -DECLOP_1VAR_COMP(double1, ==) -DECLOP_1VAR_COMP(double1, !=) -DECLOP_1VAR_COMP(double1, <) -DECLOP_1VAR_COMP(double1, >) -DECLOP_1VAR_COMP(double1, <=) -DECLOP_1VAR_COMP(double1, >=) - -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(double1, float) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(double1, double) -DECLOP_1VAR_SCALE_PRODUCT(double1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(double1, signed long long) - -// DOUBLE2 - -DECLOP_2VAR_2IN_1OUT(double2, +) -DECLOP_2VAR_2IN_1OUT(double2, -) -DECLOP_2VAR_2IN_1OUT(double2, *) -DECLOP_2VAR_2IN_1OUT(double2, /) - -DECLOP_2VAR_ASSIGN(double2, +=) -DECLOP_2VAR_ASSIGN(double2, -=) -DECLOP_2VAR_ASSIGN(double2, *=) -DECLOP_2VAR_ASSIGN(double2, /=) - -DECLOP_2VAR_PREOP(double2, ++) -DECLOP_2VAR_PREOP(double2, --) - -DECLOP_2VAR_POSTOP(double2, ++) -DECLOP_2VAR_POSTOP(double2, --) - -DECLOP_2VAR_COMP(double2, ==) -DECLOP_2VAR_COMP(double2, !=) -DECLOP_2VAR_COMP(double2, <) -DECLOP_2VAR_COMP(double2, >) -DECLOP_2VAR_COMP(double2, <=) -DECLOP_2VAR_COMP(double2, >=) - -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(double2, float) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(double2, double) -DECLOP_2VAR_SCALE_PRODUCT(double2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(double2, signed long long) - -// DOUBLE3 - -DECLOP_3VAR_2IN_1OUT(double3, +) -DECLOP_3VAR_2IN_1OUT(double3, -) -DECLOP_3VAR_2IN_1OUT(double3, *) -DECLOP_3VAR_2IN_1OUT(double3, /) - -DECLOP_3VAR_ASSIGN(double3, +=) -DECLOP_3VAR_ASSIGN(double3, -=) -DECLOP_3VAR_ASSIGN(double3, *=) -DECLOP_3VAR_ASSIGN(double3, /=) - -DECLOP_3VAR_PREOP(double3, ++) -DECLOP_3VAR_PREOP(double3, --) - -DECLOP_3VAR_POSTOP(double3, ++) -DECLOP_3VAR_POSTOP(double3, --) - -DECLOP_3VAR_COMP(double3, ==) -DECLOP_3VAR_COMP(double3, !=) -DECLOP_3VAR_COMP(double3, <) -DECLOP_3VAR_COMP(double3, >) -DECLOP_3VAR_COMP(double3, <=) -DECLOP_3VAR_COMP(double3, >=) - -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(double3, float) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(double3, double) -DECLOP_3VAR_SCALE_PRODUCT(double3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(double3, signed long long) - -// DOUBLE4 - -DECLOP_4VAR_2IN_1OUT(double4, +) -DECLOP_4VAR_2IN_1OUT(double4, -) -DECLOP_4VAR_2IN_1OUT(double4, *) -DECLOP_4VAR_2IN_1OUT(double4, /) - -DECLOP_4VAR_ASSIGN(double4, +=) -DECLOP_4VAR_ASSIGN(double4, -=) -DECLOP_4VAR_ASSIGN(double4, *=) -DECLOP_4VAR_ASSIGN(double4, /=) - -DECLOP_4VAR_PREOP(double4, ++) -DECLOP_4VAR_PREOP(double4, --) - -DECLOP_4VAR_POSTOP(double4, ++) -DECLOP_4VAR_POSTOP(double4, --) - -DECLOP_4VAR_COMP(double4, ==) -DECLOP_4VAR_COMP(double4, !=) -DECLOP_4VAR_COMP(double4, <) -DECLOP_4VAR_COMP(double4, >) -DECLOP_4VAR_COMP(double4, <=) -DECLOP_4VAR_COMP(double4, >=) - -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(double4, float) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(double4, double) -DECLOP_4VAR_SCALE_PRODUCT(double4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(double4, signed long long) - -// UNSIGNED LONG1 - -DECLOP_1VAR_2IN_1OUT(ulong1, +) -DECLOP_1VAR_2IN_1OUT(ulong1, -) -DECLOP_1VAR_2IN_1OUT(ulong1, *) -DECLOP_1VAR_2IN_1OUT(ulong1, /) -DECLOP_1VAR_2IN_1OUT(ulong1, %) -DECLOP_1VAR_2IN_1OUT(ulong1, &) -DECLOP_1VAR_2IN_1OUT(ulong1, |) -DECLOP_1VAR_2IN_1OUT(ulong1, ^) -DECLOP_1VAR_2IN_1OUT(ulong1, <<) -DECLOP_1VAR_2IN_1OUT(ulong1, >>) - - -DECLOP_1VAR_ASSIGN(ulong1, +=) -DECLOP_1VAR_ASSIGN(ulong1, -=) -DECLOP_1VAR_ASSIGN(ulong1, *=) -DECLOP_1VAR_ASSIGN(ulong1, /=) -DECLOP_1VAR_ASSIGN(ulong1, %=) -DECLOP_1VAR_ASSIGN(ulong1, &=) -DECLOP_1VAR_ASSIGN(ulong1, |=) -DECLOP_1VAR_ASSIGN(ulong1, ^=) -DECLOP_1VAR_ASSIGN(ulong1, <<=) -DECLOP_1VAR_ASSIGN(ulong1, >>=) - -DECLOP_1VAR_PREOP(ulong1, ++) -DECLOP_1VAR_PREOP(ulong1, --) - -DECLOP_1VAR_POSTOP(ulong1, ++) -DECLOP_1VAR_POSTOP(ulong1, --) - -DECLOP_1VAR_COMP(ulong1, ==) -DECLOP_1VAR_COMP(ulong1, !=) -DECLOP_1VAR_COMP(ulong1, <) -DECLOP_1VAR_COMP(ulong1, >) -DECLOP_1VAR_COMP(ulong1, <=) -DECLOP_1VAR_COMP(ulong1, >=) - -DECLOP_1VAR_COMP(ulong1, &&) -DECLOP_1VAR_COMP(ulong1, ||) - -DECLOP_1VAR_1IN_1OUT(ulong1, ~) -DECLOP_1VAR_1IN_BOOLOUT(ulong1, !) - -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, float) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, double) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(ulong1, signed long long) - -// UNSIGNED LONG2 - -DECLOP_2VAR_2IN_1OUT(ulong2, +) -DECLOP_2VAR_2IN_1OUT(ulong2, -) -DECLOP_2VAR_2IN_1OUT(ulong2, *) -DECLOP_2VAR_2IN_1OUT(ulong2, /) -DECLOP_2VAR_2IN_1OUT(ulong2, %) -DECLOP_2VAR_2IN_1OUT(ulong2, &) -DECLOP_2VAR_2IN_1OUT(ulong2, |) -DECLOP_2VAR_2IN_1OUT(ulong2, ^) -DECLOP_2VAR_2IN_1OUT(ulong2, <<) -DECLOP_2VAR_2IN_1OUT(ulong2, >>) - -DECLOP_2VAR_ASSIGN(ulong2, +=) -DECLOP_2VAR_ASSIGN(ulong2, -=) -DECLOP_2VAR_ASSIGN(ulong2, *=) -DECLOP_2VAR_ASSIGN(ulong2, /=) -DECLOP_2VAR_ASSIGN(ulong2, %=) -DECLOP_2VAR_ASSIGN(ulong2, &=) -DECLOP_2VAR_ASSIGN(ulong2, |=) -DECLOP_2VAR_ASSIGN(ulong2, ^=) -DECLOP_2VAR_ASSIGN(ulong2, <<=) -DECLOP_2VAR_ASSIGN(ulong2, >>=) - -DECLOP_2VAR_PREOP(ulong2, ++) -DECLOP_2VAR_PREOP(ulong2, --) - -DECLOP_2VAR_POSTOP(ulong2, ++) -DECLOP_2VAR_POSTOP(ulong2, --) - -DECLOP_2VAR_COMP(ulong2, ==) -DECLOP_2VAR_COMP(ulong2, !=) -DECLOP_2VAR_COMP(ulong2, <) -DECLOP_2VAR_COMP(ulong2, >) -DECLOP_2VAR_COMP(ulong2, <=) -DECLOP_2VAR_COMP(ulong2, >=) - -DECLOP_2VAR_COMP(ulong2, &&) -DECLOP_2VAR_COMP(ulong2, ||) - -DECLOP_2VAR_1IN_1OUT(ulong2, ~) -DECLOP_2VAR_1IN_BOOLOUT(ulong2, !) - -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, float) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, double) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(ulong2, signed long long) - -// UNSIGNED LONG3 - -DECLOP_3VAR_2IN_1OUT(ulong3, +) -DECLOP_3VAR_2IN_1OUT(ulong3, -) -DECLOP_3VAR_2IN_1OUT(ulong3, *) -DECLOP_3VAR_2IN_1OUT(ulong3, /) -DECLOP_3VAR_2IN_1OUT(ulong3, %) -DECLOP_3VAR_2IN_1OUT(ulong3, &) -DECLOP_3VAR_2IN_1OUT(ulong3, |) -DECLOP_3VAR_2IN_1OUT(ulong3, ^) -DECLOP_3VAR_2IN_1OUT(ulong3, <<) -DECLOP_3VAR_2IN_1OUT(ulong3, >>) - -DECLOP_3VAR_ASSIGN(ulong3, +=) -DECLOP_3VAR_ASSIGN(ulong3, -=) -DECLOP_3VAR_ASSIGN(ulong3, *=) -DECLOP_3VAR_ASSIGN(ulong3, /=) -DECLOP_3VAR_ASSIGN(ulong3, %=) -DECLOP_3VAR_ASSIGN(ulong3, &=) -DECLOP_3VAR_ASSIGN(ulong3, |=) -DECLOP_3VAR_ASSIGN(ulong3, ^=) -DECLOP_3VAR_ASSIGN(ulong3, <<=) -DECLOP_3VAR_ASSIGN(ulong3, >>=) - -DECLOP_3VAR_PREOP(ulong3, ++) -DECLOP_3VAR_PREOP(ulong3, --) - -DECLOP_3VAR_POSTOP(ulong3, ++) -DECLOP_3VAR_POSTOP(ulong3, --) - -DECLOP_3VAR_COMP(ulong3, ==) -DECLOP_3VAR_COMP(ulong3, !=) -DECLOP_3VAR_COMP(ulong3, <) -DECLOP_3VAR_COMP(ulong3, >) -DECLOP_3VAR_COMP(ulong3, <=) -DECLOP_3VAR_COMP(ulong3, >=) - -DECLOP_3VAR_COMP(ulong3, &&) -DECLOP_3VAR_COMP(ulong3, ||) - -DECLOP_3VAR_1IN_1OUT(ulong3, ~) -DECLOP_3VAR_1IN_BOOLOUT(ulong3, !) - -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, float) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, double) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(ulong3, signed long long) - -// UNSIGNED LONG4 - -DECLOP_4VAR_2IN_1OUT(ulong4, +) -DECLOP_4VAR_2IN_1OUT(ulong4, -) -DECLOP_4VAR_2IN_1OUT(ulong4, *) -DECLOP_4VAR_2IN_1OUT(ulong4, /) -DECLOP_4VAR_2IN_1OUT(ulong4, %) -DECLOP_4VAR_2IN_1OUT(ulong4, &) -DECLOP_4VAR_2IN_1OUT(ulong4, |) -DECLOP_4VAR_2IN_1OUT(ulong4, ^) -DECLOP_4VAR_2IN_1OUT(ulong4, <<) -DECLOP_4VAR_2IN_1OUT(ulong4, >>) - -DECLOP_4VAR_ASSIGN(ulong4, +=) -DECLOP_4VAR_ASSIGN(ulong4, -=) -DECLOP_4VAR_ASSIGN(ulong4, *=) -DECLOP_4VAR_ASSIGN(ulong4, /=) -DECLOP_4VAR_ASSIGN(ulong4, %=) -DECLOP_4VAR_ASSIGN(ulong4, &=) -DECLOP_4VAR_ASSIGN(ulong4, |=) -DECLOP_4VAR_ASSIGN(ulong4, ^=) -DECLOP_4VAR_ASSIGN(ulong4, <<=) -DECLOP_4VAR_ASSIGN(ulong4, >>=) - -DECLOP_4VAR_PREOP(ulong4, ++) -DECLOP_4VAR_PREOP(ulong4, --) - -DECLOP_4VAR_POSTOP(ulong4, ++) -DECLOP_4VAR_POSTOP(ulong4, --) - -DECLOP_4VAR_COMP(ulong4, ==) -DECLOP_4VAR_COMP(ulong4, !=) -DECLOP_4VAR_COMP(ulong4, <) -DECLOP_4VAR_COMP(ulong4, >) -DECLOP_4VAR_COMP(ulong4, <=) -DECLOP_4VAR_COMP(ulong4, >=) - -DECLOP_4VAR_COMP(ulong4, &&) -DECLOP_4VAR_COMP(ulong4, ||) - -DECLOP_4VAR_1IN_1OUT(ulong4, ~) -DECLOP_4VAR_1IN_BOOLOUT(ulong4, !) - -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, float) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, double) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(ulong4, signed long long) - -// SIGNED LONG1 - -DECLOP_1VAR_2IN_1OUT(long1, +) -DECLOP_1VAR_2IN_1OUT(long1, -) -DECLOP_1VAR_2IN_1OUT(long1, *) -DECLOP_1VAR_2IN_1OUT(long1, /) -DECLOP_1VAR_2IN_1OUT(long1, %) -DECLOP_1VAR_2IN_1OUT(long1, &) -DECLOP_1VAR_2IN_1OUT(long1, |) -DECLOP_1VAR_2IN_1OUT(long1, ^) -DECLOP_1VAR_2IN_1OUT(long1, <<) -DECLOP_1VAR_2IN_1OUT(long1, >>) - - -DECLOP_1VAR_ASSIGN(long1, +=) -DECLOP_1VAR_ASSIGN(long1, -=) -DECLOP_1VAR_ASSIGN(long1, *=) -DECLOP_1VAR_ASSIGN(long1, /=) -DECLOP_1VAR_ASSIGN(long1, %=) -DECLOP_1VAR_ASSIGN(long1, &=) -DECLOP_1VAR_ASSIGN(long1, |=) -DECLOP_1VAR_ASSIGN(long1, ^=) -DECLOP_1VAR_ASSIGN(long1, <<=) -DECLOP_1VAR_ASSIGN(long1, >>=) - -DECLOP_1VAR_PREOP(long1, ++) -DECLOP_1VAR_PREOP(long1, --) - -DECLOP_1VAR_POSTOP(long1, ++) -DECLOP_1VAR_POSTOP(long1, --) - -DECLOP_1VAR_COMP(long1, ==) -DECLOP_1VAR_COMP(long1, !=) -DECLOP_1VAR_COMP(long1, <) -DECLOP_1VAR_COMP(long1, >) -DECLOP_1VAR_COMP(long1, <=) -DECLOP_1VAR_COMP(long1, >=) - -DECLOP_1VAR_COMP(long1, &&) -DECLOP_1VAR_COMP(long1, ||) - -DECLOP_1VAR_1IN_1OUT(long1, ~) -DECLOP_1VAR_1IN_BOOLOUT(long1, !) - -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(long1, float) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(long1, double) -DECLOP_1VAR_SCALE_PRODUCT(long1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(long1, signed long long) - -// SIGNED LONG2 - -DECLOP_2VAR_2IN_1OUT(long2, +) -DECLOP_2VAR_2IN_1OUT(long2, -) -DECLOP_2VAR_2IN_1OUT(long2, *) -DECLOP_2VAR_2IN_1OUT(long2, /) -DECLOP_2VAR_2IN_1OUT(long2, %) -DECLOP_2VAR_2IN_1OUT(long2, &) -DECLOP_2VAR_2IN_1OUT(long2, |) -DECLOP_2VAR_2IN_1OUT(long2, ^) -DECLOP_2VAR_2IN_1OUT(long2, <<) -DECLOP_2VAR_2IN_1OUT(long2, >>) - -DECLOP_2VAR_ASSIGN(long2, +=) -DECLOP_2VAR_ASSIGN(long2, -=) -DECLOP_2VAR_ASSIGN(long2, *=) -DECLOP_2VAR_ASSIGN(long2, /=) -DECLOP_2VAR_ASSIGN(long2, %=) -DECLOP_2VAR_ASSIGN(long2, &=) -DECLOP_2VAR_ASSIGN(long2, |=) -DECLOP_2VAR_ASSIGN(long2, ^=) -DECLOP_2VAR_ASSIGN(long2, <<=) -DECLOP_2VAR_ASSIGN(long2, >>=) - -DECLOP_2VAR_PREOP(long2, ++) -DECLOP_2VAR_PREOP(long2, --) - -DECLOP_2VAR_POSTOP(long2, ++) -DECLOP_2VAR_POSTOP(long2, --) - -DECLOP_2VAR_COMP(long2, ==) -DECLOP_2VAR_COMP(long2, !=) -DECLOP_2VAR_COMP(long2, <) -DECLOP_2VAR_COMP(long2, >) -DECLOP_2VAR_COMP(long2, <=) -DECLOP_2VAR_COMP(long2, >=) - -DECLOP_2VAR_COMP(long2, &&) -DECLOP_2VAR_COMP(long2, ||) - -DECLOP_2VAR_1IN_1OUT(long2, ~) -DECLOP_2VAR_1IN_BOOLOUT(long2, !) - -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(long2, float) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(long2, double) -DECLOP_2VAR_SCALE_PRODUCT(long2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(long2, signed long long) - -// SIGNED LONG3 - -DECLOP_3VAR_2IN_1OUT(long3, +) -DECLOP_3VAR_2IN_1OUT(long3, -) -DECLOP_3VAR_2IN_1OUT(long3, *) -DECLOP_3VAR_2IN_1OUT(long3, /) -DECLOP_3VAR_2IN_1OUT(long3, %) -DECLOP_3VAR_2IN_1OUT(long3, &) -DECLOP_3VAR_2IN_1OUT(long3, |) -DECLOP_3VAR_2IN_1OUT(long3, ^) -DECLOP_3VAR_2IN_1OUT(long3, <<) -DECLOP_3VAR_2IN_1OUT(long3, >>) - -DECLOP_3VAR_ASSIGN(long3, +=) -DECLOP_3VAR_ASSIGN(long3, -=) -DECLOP_3VAR_ASSIGN(long3, *=) -DECLOP_3VAR_ASSIGN(long3, /=) -DECLOP_3VAR_ASSIGN(long3, %=) -DECLOP_3VAR_ASSIGN(long3, &=) -DECLOP_3VAR_ASSIGN(long3, |=) -DECLOP_3VAR_ASSIGN(long3, ^=) -DECLOP_3VAR_ASSIGN(long3, <<=) -DECLOP_3VAR_ASSIGN(long3, >>=) - -DECLOP_3VAR_PREOP(long3, ++) -DECLOP_3VAR_PREOP(long3, --) - -DECLOP_3VAR_POSTOP(long3, ++) -DECLOP_3VAR_POSTOP(long3, --) - -DECLOP_3VAR_COMP(long3, ==) -DECLOP_3VAR_COMP(long3, !=) -DECLOP_3VAR_COMP(long3, <) -DECLOP_3VAR_COMP(long3, >) -DECLOP_3VAR_COMP(long3, <=) -DECLOP_3VAR_COMP(long3, >=) - -DECLOP_3VAR_COMP(long3, &&) -DECLOP_3VAR_COMP(long3, ||) - -DECLOP_3VAR_1IN_1OUT(long3, ~) -DECLOP_3VAR_1IN_BOOLOUT(long3, !) - -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(long3, float) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(long3, double) -DECLOP_3VAR_SCALE_PRODUCT(long3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(long3, signed long long) - -// SIGNED LONG4 - -DECLOP_4VAR_2IN_1OUT(long4, +) -DECLOP_4VAR_2IN_1OUT(long4, -) -DECLOP_4VAR_2IN_1OUT(long4, *) -DECLOP_4VAR_2IN_1OUT(long4, /) -DECLOP_4VAR_2IN_1OUT(long4, %) -DECLOP_4VAR_2IN_1OUT(long4, &) -DECLOP_4VAR_2IN_1OUT(long4, |) -DECLOP_4VAR_2IN_1OUT(long4, ^) -DECLOP_4VAR_2IN_1OUT(long4, <<) -DECLOP_4VAR_2IN_1OUT(long4, >>) - -DECLOP_4VAR_ASSIGN(long4, +=) -DECLOP_4VAR_ASSIGN(long4, -=) -DECLOP_4VAR_ASSIGN(long4, *=) -DECLOP_4VAR_ASSIGN(long4, /=) -DECLOP_4VAR_ASSIGN(long4, %=) -DECLOP_4VAR_ASSIGN(long4, &=) -DECLOP_4VAR_ASSIGN(long4, |=) -DECLOP_4VAR_ASSIGN(long4, ^=) -DECLOP_4VAR_ASSIGN(long4, <<=) -DECLOP_4VAR_ASSIGN(long4, >>=) - -DECLOP_4VAR_PREOP(long4, ++) -DECLOP_4VAR_PREOP(long4, --) - -DECLOP_4VAR_POSTOP(long4, ++) -DECLOP_4VAR_POSTOP(long4, --) - -DECLOP_4VAR_COMP(long4, ==) -DECLOP_4VAR_COMP(long4, !=) -DECLOP_4VAR_COMP(long4, <) -DECLOP_4VAR_COMP(long4, >) -DECLOP_4VAR_COMP(long4, <=) -DECLOP_4VAR_COMP(long4, >=) - -DECLOP_4VAR_COMP(long4, &&) -DECLOP_4VAR_COMP(long4, ||) - -DECLOP_4VAR_1IN_1OUT(long4, ~) -DECLOP_4VAR_1IN_BOOLOUT(long4, !) - -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(long4, float) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(long4, double) -DECLOP_4VAR_SCALE_PRODUCT(long4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(long4, signed long long) - -// UNSIGNED LONGLONG1 - -DECLOP_1VAR_2IN_1OUT(ulonglong1, +) -DECLOP_1VAR_2IN_1OUT(ulonglong1, -) -DECLOP_1VAR_2IN_1OUT(ulonglong1, *) -DECLOP_1VAR_2IN_1OUT(ulonglong1, /) -DECLOP_1VAR_2IN_1OUT(ulonglong1, %) -DECLOP_1VAR_2IN_1OUT(ulonglong1, &) -DECLOP_1VAR_2IN_1OUT(ulonglong1, |) -DECLOP_1VAR_2IN_1OUT(ulonglong1, ^) -DECLOP_1VAR_2IN_1OUT(ulonglong1, <<) -DECLOP_1VAR_2IN_1OUT(ulonglong1, >>) - - -DECLOP_1VAR_ASSIGN(ulonglong1, +=) -DECLOP_1VAR_ASSIGN(ulonglong1, -=) -DECLOP_1VAR_ASSIGN(ulonglong1, *=) -DECLOP_1VAR_ASSIGN(ulonglong1, /=) -DECLOP_1VAR_ASSIGN(ulonglong1, %=) -DECLOP_1VAR_ASSIGN(ulonglong1, &=) -DECLOP_1VAR_ASSIGN(ulonglong1, |=) -DECLOP_1VAR_ASSIGN(ulonglong1, ^=) -DECLOP_1VAR_ASSIGN(ulonglong1, <<=) -DECLOP_1VAR_ASSIGN(ulonglong1, >>=) - -DECLOP_1VAR_PREOP(ulonglong1, ++) -DECLOP_1VAR_PREOP(ulonglong1, --) - -DECLOP_1VAR_POSTOP(ulonglong1, ++) -DECLOP_1VAR_POSTOP(ulonglong1, --) - -DECLOP_1VAR_COMP(ulonglong1, ==) -DECLOP_1VAR_COMP(ulonglong1, !=) -DECLOP_1VAR_COMP(ulonglong1, <) -DECLOP_1VAR_COMP(ulonglong1, >) -DECLOP_1VAR_COMP(ulonglong1, <=) -DECLOP_1VAR_COMP(ulonglong1, >=) - -DECLOP_1VAR_COMP(ulonglong1, &&) -DECLOP_1VAR_COMP(ulonglong1, ||) - -DECLOP_1VAR_1IN_1OUT(ulonglong1, ~) -DECLOP_1VAR_1IN_BOOLOUT(ulonglong1, !) - -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, float) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, double) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(ulonglong1, signed long long) - -// UNSIGNED LONGLONG2 - -DECLOP_2VAR_2IN_1OUT(ulonglong2, +) -DECLOP_2VAR_2IN_1OUT(ulonglong2, -) -DECLOP_2VAR_2IN_1OUT(ulonglong2, *) -DECLOP_2VAR_2IN_1OUT(ulonglong2, /) -DECLOP_2VAR_2IN_1OUT(ulonglong2, %) -DECLOP_2VAR_2IN_1OUT(ulonglong2, &) -DECLOP_2VAR_2IN_1OUT(ulonglong2, |) -DECLOP_2VAR_2IN_1OUT(ulonglong2, ^) -DECLOP_2VAR_2IN_1OUT(ulonglong2, <<) -DECLOP_2VAR_2IN_1OUT(ulonglong2, >>) - -DECLOP_2VAR_ASSIGN(ulonglong2, +=) -DECLOP_2VAR_ASSIGN(ulonglong2, -=) -DECLOP_2VAR_ASSIGN(ulonglong2, *=) -DECLOP_2VAR_ASSIGN(ulonglong2, /=) -DECLOP_2VAR_ASSIGN(ulonglong2, %=) -DECLOP_2VAR_ASSIGN(ulonglong2, &=) -DECLOP_2VAR_ASSIGN(ulonglong2, |=) -DECLOP_2VAR_ASSIGN(ulonglong2, ^=) -DECLOP_2VAR_ASSIGN(ulonglong2, <<=) -DECLOP_2VAR_ASSIGN(ulonglong2, >>=) - -DECLOP_2VAR_PREOP(ulonglong2, ++) -DECLOP_2VAR_PREOP(ulonglong2, --) - -DECLOP_2VAR_POSTOP(ulonglong2, ++) -DECLOP_2VAR_POSTOP(ulonglong2, --) - -DECLOP_2VAR_COMP(ulonglong2, ==) -DECLOP_2VAR_COMP(ulonglong2, !=) -DECLOP_2VAR_COMP(ulonglong2, <) -DECLOP_2VAR_COMP(ulonglong2, >) -DECLOP_2VAR_COMP(ulonglong2, <=) -DECLOP_2VAR_COMP(ulonglong2, >=) - -DECLOP_2VAR_COMP(ulonglong2, &&) -DECLOP_2VAR_COMP(ulonglong2, ||) - -DECLOP_2VAR_1IN_1OUT(ulonglong2, ~) -DECLOP_2VAR_1IN_BOOLOUT(ulonglong2, !) - -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, float) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, double) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(ulonglong2, signed long long) - -// UNSIGNED LONGLONG3 - -DECLOP_3VAR_2IN_1OUT(ulonglong3, +) -DECLOP_3VAR_2IN_1OUT(ulonglong3, -) -DECLOP_3VAR_2IN_1OUT(ulonglong3, *) -DECLOP_3VAR_2IN_1OUT(ulonglong3, /) -DECLOP_3VAR_2IN_1OUT(ulonglong3, %) -DECLOP_3VAR_2IN_1OUT(ulonglong3, &) -DECLOP_3VAR_2IN_1OUT(ulonglong3, |) -DECLOP_3VAR_2IN_1OUT(ulonglong3, ^) -DECLOP_3VAR_2IN_1OUT(ulonglong3, <<) -DECLOP_3VAR_2IN_1OUT(ulonglong3, >>) - -DECLOP_3VAR_ASSIGN(ulonglong3, +=) -DECLOP_3VAR_ASSIGN(ulonglong3, -=) -DECLOP_3VAR_ASSIGN(ulonglong3, *=) -DECLOP_3VAR_ASSIGN(ulonglong3, /=) -DECLOP_3VAR_ASSIGN(ulonglong3, %=) -DECLOP_3VAR_ASSIGN(ulonglong3, &=) -DECLOP_3VAR_ASSIGN(ulonglong3, |=) -DECLOP_3VAR_ASSIGN(ulonglong3, ^=) -DECLOP_3VAR_ASSIGN(ulonglong3, <<=) -DECLOP_3VAR_ASSIGN(ulonglong3, >>=) - -DECLOP_3VAR_PREOP(ulonglong3, ++) -DECLOP_3VAR_PREOP(ulonglong3, --) - -DECLOP_3VAR_POSTOP(ulonglong3, ++) -DECLOP_3VAR_POSTOP(ulonglong3, --) - -DECLOP_3VAR_COMP(ulonglong3, ==) -DECLOP_3VAR_COMP(ulonglong3, !=) -DECLOP_3VAR_COMP(ulonglong3, <) -DECLOP_3VAR_COMP(ulonglong3, >) -DECLOP_3VAR_COMP(ulonglong3, <=) -DECLOP_3VAR_COMP(ulonglong3, >=) - -DECLOP_3VAR_COMP(ulonglong3, &&) -DECLOP_3VAR_COMP(ulonglong3, ||) - -DECLOP_3VAR_1IN_1OUT(ulonglong3, ~) -DECLOP_3VAR_1IN_BOOLOUT(ulonglong3, !) - -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, float) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, double) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(ulonglong3, signed long long) - -// UNSIGNED LONGLONG4 - -DECLOP_4VAR_2IN_1OUT(ulonglong4, +) -DECLOP_4VAR_2IN_1OUT(ulonglong4, -) -DECLOP_4VAR_2IN_1OUT(ulonglong4, *) -DECLOP_4VAR_2IN_1OUT(ulonglong4, /) -DECLOP_4VAR_2IN_1OUT(ulonglong4, %) -DECLOP_4VAR_2IN_1OUT(ulonglong4, &) -DECLOP_4VAR_2IN_1OUT(ulonglong4, |) -DECLOP_4VAR_2IN_1OUT(ulonglong4, ^) -DECLOP_4VAR_2IN_1OUT(ulonglong4, <<) -DECLOP_4VAR_2IN_1OUT(ulonglong4, >>) - -DECLOP_4VAR_ASSIGN(ulonglong4, +=) -DECLOP_4VAR_ASSIGN(ulonglong4, -=) -DECLOP_4VAR_ASSIGN(ulonglong4, *=) -DECLOP_4VAR_ASSIGN(ulonglong4, /=) -DECLOP_4VAR_ASSIGN(ulonglong4, %=) -DECLOP_4VAR_ASSIGN(ulonglong4, &=) -DECLOP_4VAR_ASSIGN(ulonglong4, |=) -DECLOP_4VAR_ASSIGN(ulonglong4, ^=) -DECLOP_4VAR_ASSIGN(ulonglong4, <<=) -DECLOP_4VAR_ASSIGN(ulonglong4, >>=) - -DECLOP_4VAR_PREOP(ulonglong4, ++) -DECLOP_4VAR_PREOP(ulonglong4, --) - -DECLOP_4VAR_POSTOP(ulonglong4, ++) -DECLOP_4VAR_POSTOP(ulonglong4, --) - -DECLOP_4VAR_COMP(ulonglong4, ==) -DECLOP_4VAR_COMP(ulonglong4, !=) -DECLOP_4VAR_COMP(ulonglong4, <) -DECLOP_4VAR_COMP(ulonglong4, >) -DECLOP_4VAR_COMP(ulonglong4, <=) -DECLOP_4VAR_COMP(ulonglong4, >=) - -DECLOP_4VAR_COMP(ulonglong4, &&) -DECLOP_4VAR_COMP(ulonglong4, ||) - -DECLOP_4VAR_1IN_1OUT(ulonglong4, ~) -DECLOP_4VAR_1IN_BOOLOUT(ulonglong4, !) - -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, float) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, double) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(ulonglong4, signed long long) - -// SIGNED LONGLONG1 - -DECLOP_1VAR_2IN_1OUT(longlong1, +) -DECLOP_1VAR_2IN_1OUT(longlong1, -) -DECLOP_1VAR_2IN_1OUT(longlong1, *) -DECLOP_1VAR_2IN_1OUT(longlong1, /) -DECLOP_1VAR_2IN_1OUT(longlong1, %) -DECLOP_1VAR_2IN_1OUT(longlong1, &) -DECLOP_1VAR_2IN_1OUT(longlong1, |) -DECLOP_1VAR_2IN_1OUT(longlong1, ^) -DECLOP_1VAR_2IN_1OUT(longlong1, <<) -DECLOP_1VAR_2IN_1OUT(longlong1, >>) - - -DECLOP_1VAR_ASSIGN(longlong1, +=) -DECLOP_1VAR_ASSIGN(longlong1, -=) -DECLOP_1VAR_ASSIGN(longlong1, *=) -DECLOP_1VAR_ASSIGN(longlong1, /=) -DECLOP_1VAR_ASSIGN(longlong1, %=) -DECLOP_1VAR_ASSIGN(longlong1, &=) -DECLOP_1VAR_ASSIGN(longlong1, |=) -DECLOP_1VAR_ASSIGN(longlong1, ^=) -DECLOP_1VAR_ASSIGN(longlong1, <<=) -DECLOP_1VAR_ASSIGN(longlong1, >>=) - -DECLOP_1VAR_PREOP(longlong1, ++) -DECLOP_1VAR_PREOP(longlong1, --) - -DECLOP_1VAR_POSTOP(longlong1, ++) -DECLOP_1VAR_POSTOP(longlong1, --) - -DECLOP_1VAR_COMP(longlong1, ==) -DECLOP_1VAR_COMP(longlong1, !=) -DECLOP_1VAR_COMP(longlong1, <) -DECLOP_1VAR_COMP(longlong1, >) -DECLOP_1VAR_COMP(longlong1, <=) -DECLOP_1VAR_COMP(longlong1, >=) - -DECLOP_1VAR_COMP(longlong1, &&) -DECLOP_1VAR_COMP(longlong1, ||) - -DECLOP_1VAR_1IN_1OUT(longlong1, ~) -DECLOP_1VAR_1IN_BOOLOUT(longlong1, !) - -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned char) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed char) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned short) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed short) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned int) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed int) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, float) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned long) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed long) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, double) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, unsigned long long) -DECLOP_1VAR_SCALE_PRODUCT(longlong1, signed long long) - -// SIGNED LONGLONG2 - -DECLOP_2VAR_2IN_1OUT(longlong2, +) -DECLOP_2VAR_2IN_1OUT(longlong2, -) -DECLOP_2VAR_2IN_1OUT(longlong2, *) -DECLOP_2VAR_2IN_1OUT(longlong2, /) -DECLOP_2VAR_2IN_1OUT(longlong2, %) -DECLOP_2VAR_2IN_1OUT(longlong2, &) -DECLOP_2VAR_2IN_1OUT(longlong2, |) -DECLOP_2VAR_2IN_1OUT(longlong2, ^) -DECLOP_2VAR_2IN_1OUT(longlong2, <<) -DECLOP_2VAR_2IN_1OUT(longlong2, >>) - -DECLOP_2VAR_ASSIGN(longlong2, +=) -DECLOP_2VAR_ASSIGN(longlong2, -=) -DECLOP_2VAR_ASSIGN(longlong2, *=) -DECLOP_2VAR_ASSIGN(longlong2, /=) -DECLOP_2VAR_ASSIGN(longlong2, %=) -DECLOP_2VAR_ASSIGN(longlong2, &=) -DECLOP_2VAR_ASSIGN(longlong2, |=) -DECLOP_2VAR_ASSIGN(longlong2, ^=) -DECLOP_2VAR_ASSIGN(longlong2, <<=) -DECLOP_2VAR_ASSIGN(longlong2, >>=) - -DECLOP_2VAR_PREOP(longlong2, ++) -DECLOP_2VAR_PREOP(longlong2, --) - -DECLOP_2VAR_POSTOP(longlong2, ++) -DECLOP_2VAR_POSTOP(longlong2, --) - -DECLOP_2VAR_COMP(longlong2, ==) -DECLOP_2VAR_COMP(longlong2, !=) -DECLOP_2VAR_COMP(longlong2, <) -DECLOP_2VAR_COMP(longlong2, >) -DECLOP_2VAR_COMP(longlong2, <=) -DECLOP_2VAR_COMP(longlong2, >=) - -DECLOP_2VAR_COMP(longlong2, &&) -DECLOP_2VAR_COMP(longlong2, ||) - -DECLOP_2VAR_1IN_1OUT(longlong2, ~) -DECLOP_2VAR_1IN_BOOLOUT(longlong2, !) - -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned char) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed char) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned short) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed short) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned int) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed int) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, float) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned long) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed long) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, double) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, unsigned long long) -DECLOP_2VAR_SCALE_PRODUCT(longlong2, signed long long) - -// SIGNED LONGLONG3 - -DECLOP_3VAR_2IN_1OUT(longlong3, +) -DECLOP_3VAR_2IN_1OUT(longlong3, -) -DECLOP_3VAR_2IN_1OUT(longlong3, *) -DECLOP_3VAR_2IN_1OUT(longlong3, /) -DECLOP_3VAR_2IN_1OUT(longlong3, %) -DECLOP_3VAR_2IN_1OUT(longlong3, &) -DECLOP_3VAR_2IN_1OUT(longlong3, |) -DECLOP_3VAR_2IN_1OUT(longlong3, ^) -DECLOP_3VAR_2IN_1OUT(longlong3, <<) -DECLOP_3VAR_2IN_1OUT(longlong3, >>) - -DECLOP_3VAR_ASSIGN(longlong3, +=) -DECLOP_3VAR_ASSIGN(longlong3, -=) -DECLOP_3VAR_ASSIGN(longlong3, *=) -DECLOP_3VAR_ASSIGN(longlong3, /=) -DECLOP_3VAR_ASSIGN(longlong3, %=) -DECLOP_3VAR_ASSIGN(longlong3, &=) -DECLOP_3VAR_ASSIGN(longlong3, |=) -DECLOP_3VAR_ASSIGN(longlong3, ^=) -DECLOP_3VAR_ASSIGN(longlong3, <<=) -DECLOP_3VAR_ASSIGN(longlong3, >>=) - -DECLOP_3VAR_PREOP(longlong3, ++) -DECLOP_3VAR_PREOP(longlong3, --) - -DECLOP_3VAR_POSTOP(longlong3, ++) -DECLOP_3VAR_POSTOP(longlong3, --) - -DECLOP_3VAR_COMP(longlong3, ==) -DECLOP_3VAR_COMP(longlong3, !=) -DECLOP_3VAR_COMP(longlong3, <) -DECLOP_3VAR_COMP(longlong3, >) -DECLOP_3VAR_COMP(longlong3, <=) -DECLOP_3VAR_COMP(longlong3, >=) - -DECLOP_3VAR_COMP(longlong3, &&) -DECLOP_3VAR_COMP(longlong3, ||) - -DECLOP_3VAR_1IN_1OUT(longlong3, ~) -DECLOP_3VAR_1IN_BOOLOUT(longlong3, !) - -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned char) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed char) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned short) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed short) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned int) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed int) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, float) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned long) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed long) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, double) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, unsigned long long) -DECLOP_3VAR_SCALE_PRODUCT(longlong3, signed long long) - -// SIGNED LONGLONG4 - -DECLOP_4VAR_2IN_1OUT(longlong4, +) -DECLOP_4VAR_2IN_1OUT(longlong4, -) -DECLOP_4VAR_2IN_1OUT(longlong4, *) -DECLOP_4VAR_2IN_1OUT(longlong4, /) -DECLOP_4VAR_2IN_1OUT(longlong4, %) -DECLOP_4VAR_2IN_1OUT(longlong4, &) -DECLOP_4VAR_2IN_1OUT(longlong4, |) -DECLOP_4VAR_2IN_1OUT(longlong4, ^) -DECLOP_4VAR_2IN_1OUT(longlong4, <<) -DECLOP_4VAR_2IN_1OUT(longlong4, >>) - -DECLOP_4VAR_ASSIGN(longlong4, +=) -DECLOP_4VAR_ASSIGN(longlong4, -=) -DECLOP_4VAR_ASSIGN(longlong4, *=) -DECLOP_4VAR_ASSIGN(longlong4, /=) -DECLOP_4VAR_ASSIGN(longlong4, %=) -DECLOP_4VAR_ASSIGN(longlong4, &=) -DECLOP_4VAR_ASSIGN(longlong4, |=) -DECLOP_4VAR_ASSIGN(longlong4, ^=) -DECLOP_4VAR_ASSIGN(longlong4, <<=) -DECLOP_4VAR_ASSIGN(longlong4, >>=) - -DECLOP_4VAR_PREOP(longlong4, ++) -DECLOP_4VAR_PREOP(longlong4, --) - -DECLOP_4VAR_POSTOP(longlong4, ++) -DECLOP_4VAR_POSTOP(longlong4, --) - -DECLOP_4VAR_COMP(longlong4, ==) -DECLOP_4VAR_COMP(longlong4, !=) -DECLOP_4VAR_COMP(longlong4, <) -DECLOP_4VAR_COMP(longlong4, >) -DECLOP_4VAR_COMP(longlong4, <=) -DECLOP_4VAR_COMP(longlong4, >=) - -DECLOP_4VAR_COMP(longlong4, &&) -DECLOP_4VAR_COMP(longlong4, ||) - -DECLOP_4VAR_1IN_1OUT(longlong4, ~) -DECLOP_4VAR_1IN_BOOLOUT(longlong4, !) - -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned char) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed char) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned short) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed short) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned int) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed int) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, float) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned long) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed long) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, double) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, unsigned long long) -DECLOP_4VAR_SCALE_PRODUCT(longlong4, signed long long) - - -#endif - - -#endif +#endif \ No newline at end of file diff --git a/hipamd/include/hip/hcc_detail/llvm_intrinsics.h b/hipamd/include/hip/hcc_detail/llvm_intrinsics.h new file mode 100644 index 0000000000..dc6fd05c52 --- /dev/null +++ b/hipamd/include/hip/hcc_detail/llvm_intrinsics.h @@ -0,0 +1,70 @@ +/* +Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. + +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. + +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. 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. +*/ + +/** + * @file hcc_detail/llvm_intrinsics.h + * @brief Contains declarations for wrapper functions for llvm intrinsics + * like llvm.amdgcn.s.barrier. + */ + +#ifndef HIP_INCLUDE_HIP_HCC_DETAIL_LLVM_INTRINSICS_H +#define HIP_INCLUDE_HIP_HCC_DETAIL_LLVM_INTRINSICS_H + +#include "hip/hcc_detail/host_defines.h" + +__device__ +__attribute__((convergent)) +ulong __llvm_amdgcn_icmp_i32(uint x, uint y, uint z) __asm("llvm.amdgcn.icmp.i32"); + +__device__ +unsigned __llvm_amdgcn_groupstaticsize() __asm("llvm.amdgcn.groupstaticsize"); + +__device__ +unsigned int __llvm_bitrev_b32(unsigned int src0) __asm("llvm.bitreverse.i32"); + +__device__ +uint64_t __llvm_bitrev_b64(uint64_t src0) __asm("llvm.bitreverse.i64"); + +extern +__device__ +__attribute__((const)) +unsigned int __mbcnt_lo(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.lo"); + +extern +__device__ +__attribute__((const)) +unsigned int __mbcnt_hi(unsigned int x, unsigned int y) __asm("llvm.amdgcn.mbcnt.hi"); + +__device__ +int __llvm_amdgcn_ds_bpermute(int index, int src) __asm("llvm.amdgcn.ds.bpermute"); + +__device__ +int __llvm_amdgcn_ds_permute(int index, int src) __asm("llvm.amdgcn.ds.permute"); + +__device__ +int __llvm_amdgcn_ds_swizzle(int index, int pattern) __asm("llvm.amdgcn.ds.swizzle"); + +__device__ +int __llvm_amdgcn_move_dpp(int src, int dpp_ctrl, int row_mask, int bank_mask, + bool bound_ctrl) __asm("llvm.amdgcn.mov.dpp.i32"); + +#endif diff --git a/hipamd/include/hip/hcc_detail/surface_functions.h b/hipamd/include/hip/hcc_detail/surface_functions.h index 562cc440ed..607f221901 100644 --- a/hipamd/include/hip/hcc_detail/surface_functions.h +++ b/hipamd/include/hip/hcc_detail/surface_functions.h @@ -23,8 +23,6 @@ THE SOFTWARE. #ifndef HIP_INCLUDE_HIP_HCC_DETAIL_SURFACE_FUNCTIONS_H #define HIP_INCLUDE_HIP_HCC_DETAIL_SURFACE_FUNCTIONS_H -#include -#include #include #define __SURFACE_FUNCTIONS_DECL__ static __inline__ __device__ diff --git a/hipamd/include/hip/hcc_detail/texture_functions.h b/hipamd/include/hip/hcc_detail/texture_functions.h index 8a7aec9212..999f97e65e 100644 --- a/hipamd/include/hip/hcc_detail/texture_functions.h +++ b/hipamd/include/hip/hcc_detail/texture_functions.h @@ -110,47 +110,47 @@ union TData { #define TEXTURE_RETURN_UNSIGNED return texel.u.x; -#define TEXTURE_RETURN_CHAR_X return char1(texel.i.x); +#define TEXTURE_RETURN_CHAR_X return make_char1(texel.i.x); -#define TEXTURE_RETURN_UCHAR_X return uchar1(texel.u.x); +#define TEXTURE_RETURN_UCHAR_X return make_uchar1(texel.u.x); -#define TEXTURE_RETURN_SHORT_X return short1(texel.i.x); +#define TEXTURE_RETURN_SHORT_X return make_short1(texel.i.x); -#define TEXTURE_RETURN_USHORT_X return ushort1(texel.u.x); +#define TEXTURE_RETURN_USHORT_X return make_ushort1(texel.u.x); -#define TEXTURE_RETURN_INT_X return int1(texel.i.x); +#define TEXTURE_RETURN_INT_X return make_int1(texel.i.x); -#define TEXTURE_RETURN_UINT_X return uint1(texel.u.x); +#define TEXTURE_RETURN_UINT_X return make_uint1(texel.u.x); -#define TEXTURE_RETURN_FLOAT_X return float1(texel.f.x); +#define TEXTURE_RETURN_FLOAT_X return make_float1(texel.f.x); -#define TEXTURE_RETURN_CHAR_XY return char2(texel.i.x, texel.i.y); +#define TEXTURE_RETURN_CHAR_XY return make_char2(texel.i.x, texel.i.y); -#define TEXTURE_RETURN_UCHAR_XY return uchar2(texel.u.x, texel.u.y); +#define TEXTURE_RETURN_UCHAR_XY return make_uchar2(texel.u.x, texel.u.y); -#define TEXTURE_RETURN_SHORT_XY return short2(texel.i.x, texel.i.y); +#define TEXTURE_RETURN_SHORT_XY return make_short2(texel.i.x, texel.i.y); -#define TEXTURE_RETURN_USHORT_XY return ushort2(texel.u.x, texel.u.y); +#define TEXTURE_RETURN_USHORT_XY return make_ushort2(texel.u.x, texel.u.y); -#define TEXTURE_RETURN_INT_XY return int2(texel.i.x, texel.i.y); +#define TEXTURE_RETURN_INT_XY return make_int2(texel.i.x, texel.i.y); -#define TEXTURE_RETURN_UINT_XY return uint2(texel.u.x, texel.u.y); +#define TEXTURE_RETURN_UINT_XY return make_uint2(texel.u.x, texel.u.y); -#define TEXTURE_RETURN_FLOAT_XY return float2(texel.f.x, texel.f.y); +#define TEXTURE_RETURN_FLOAT_XY return make_float2(texel.f.x, texel.f.y); -#define TEXTURE_RETURN_CHAR_XYZW return char4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); +#define TEXTURE_RETURN_CHAR_XYZW return make_char4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); -#define TEXTURE_RETURN_UCHAR_XYZW return uchar4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); +#define TEXTURE_RETURN_UCHAR_XYZW return make_uchar4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); -#define TEXTURE_RETURN_SHORT_XYZW return short4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); +#define TEXTURE_RETURN_SHORT_XYZW return make_short4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); -#define TEXTURE_RETURN_USHORT_XYZW return ushort4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); +#define TEXTURE_RETURN_USHORT_XYZW return make_ushort4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); -#define TEXTURE_RETURN_INT_XYZW return int4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); +#define TEXTURE_RETURN_INT_XYZW return make_int4(texel.i.x, texel.i.y, texel.i.z, texel.i.w); -#define TEXTURE_RETURN_UINT_XYZW return uint4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); +#define TEXTURE_RETURN_UINT_XYZW return make_uint4(texel.u.x, texel.u.y, texel.u.z, texel.u.w); -#define TEXTURE_RETURN_FLOAT_XYZW return float4(texel.f.x, texel.f.y, texel.f.z, texel.f.w); +#define TEXTURE_RETURN_FLOAT_XYZW return make_float4(texel.f.x, texel.f.y, texel.f.z, texel.f.w); extern "C" { hc::short_vector::float4::vector_value_type __ockl_image_sample_1D(unsigned int ADDRESS_SPACE_CONSTANT* i, diff --git a/hipamd/include/hip/hip_runtime_api.h b/hipamd/include/hip/hip_runtime_api.h index 2ff562cc01..cd7af65265 100644 --- a/hipamd/include/hip/hip_runtime_api.h +++ b/hipamd/include/hip/hip_runtime_api.h @@ -297,7 +297,7 @@ enum hipComputeMode { hipComputeModeDefault = 0, hipComputeModeExclusive = 1, hipComputeModeProhibited = 2, - hipComputeModeExcusiveProcess = 3 + hipComputeModeExclusiveProcess = 3 }; /** diff --git a/hipamd/include/hip/nvcc_detail/hip_runtime_api.h b/hipamd/include/hip/nvcc_detail/hip_runtime_api.h index 3b8a3661f7..55a3794846 100644 --- a/hipamd/include/hip/nvcc_detail/hip_runtime_api.h +++ b/hipamd/include/hip/nvcc_detail/hip_runtime_api.h @@ -163,6 +163,7 @@ typedef cudaSurfaceObject_t hipSurfaceObject_t; #define hipTextureType1D cudaTextureType1D #define hipTextureType1DLayered cudaTextureType1DLayered #define hipTextureType2D cudaTextureType2D +#define hipTextureType2DLayered cudaTextureType2DLayered #define hipTextureType3D cudaTextureType3D #define hipDeviceMapHost cudaDeviceMapHost @@ -1168,20 +1169,20 @@ inline static hipError_t hipOccupancyMaxPotentialBlockSize(int* minGridSize, int return hipCUDAErrorTohipError(cerror); } -template +template inline static hipError_t hipBindTexture(size_t* offset, const struct texture& tex, const void* devPtr, size_t size = UINT_MAX) { return hipCUDAErrorTohipError(cudaBindTexture(offset, tex, devPtr, size)); } -template +template inline static hipError_t hipBindTexture(size_t* offset, struct texture& tex, const void* devPtr, const struct hipChannelFormatDesc& desc, size_t size = UINT_MAX) { return hipCUDAErrorTohipError(cudaBindTexture(offset, tex, devPtr, desc, size)); } -template +template inline static hipError_t hipUnbindTexture(struct texture* tex) { return hipCUDAErrorTohipError(cudaUnbindTexture(tex)); } @@ -1198,7 +1199,14 @@ inline static hipError_t hipBindTextureToArray(struct texture& return hipCUDAErrorTohipError(cudaBindTextureToArray(tex, array, desc)); } -template +template +inline static hipError_t hipBindTextureToArray(struct texture *tex, + hipArray_const_t array, + const struct hipChannelFormatDesc* desc) { + return hipCUDAErrorTohipError(cudaBindTextureToArray(tex, array, desc)); +} + +template inline static hipError_t hipBindTextureToArray(struct texture& tex, hipArray_const_t array) { return hipCUDAErrorTohipError(cudaBindTextureToArray(tex, array)); @@ -1239,6 +1247,16 @@ inline static hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDe hipTextureObject_t textureObject) { return hipCUDAErrorTohipError(cudaGetTextureObjectResourceDesc( pResDesc, textureObject)); } + +inline static hipError_t hipGetTextureAlignmentOffset(size_t* offset, const textureReference* texref) +{ + return hipCUDAErrorTohipError(cudaGetTextureAlignmentOffset(offset,texref)); +} + +inline static hipError_t hipGetChannelDesc(hipChannelFormatDesc* desc, hipArray_const_t array) +{ + return hipCUDAErrorTohipError(cudaGetChannelDesc(desc,array)); +} #endif //__CUDACC__ #endif // HIP_INCLUDE_HIP_NVCC_DETAIL_HIP_RUNTIME_API_H diff --git a/hipamd/packaging/hip_hcc.txt b/hipamd/packaging/hip_hcc.txt index 04293f2044..9d4b96761d 100644 --- a/hipamd/packaging/hip_hcc.txt +++ b/hipamd/packaging/hip_hcc.txt @@ -5,7 +5,6 @@ install(FILES @PROJECT_BINARY_DIR@/libhip_hcc.so DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/libhip_hcc_static.a DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/libhip_device.a DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/.hipInfo DESTINATION lib) -install(FILES @hip_SOURCE_DIR@/src/hip_hc.ll DESTINATION lib) install(FILES @PROJECT_BINARY_DIR@/hip-config.cmake @PROJECT_BINARY_DIR@/hip-config-version.cmake DESTINATION lib/cmake/hip) install(FILES @hip_SOURCE_DIR@/packaging/hip-targets.cmake @hip_SOURCE_DIR@/packaging/hip-targets-release.cmake DESTINATION lib/cmake/hip) diff --git a/hipamd/src/code_object_bundle.cpp b/hipamd/src/code_object_bundle.cpp index ede7090a52..91258f0c75 100644 --- a/hipamd/src/code_object_bundle.cpp +++ b/hipamd/src/code_object_bundle.cpp @@ -38,7 +38,7 @@ std::string isa_name(std::string triple) hsa_isa_from_name(triple.c_str(), &tmp) != HSA_STATUS_SUCCESS}; if (is_old_rocr) { - auto tmp{triple.substr(triple.rfind('x') + 1)}; + std::string tmp{triple.substr(triple.rfind('x') + 1)}; triple.replace(0, std::string::npos, "AMD:AMDGPU"); for (auto&& x : tmp) { @@ -51,7 +51,7 @@ std::string isa_name(std::string triple) } hsa_isa_t hip_impl::triple_to_hsa_isa(const std::string& triple) { - const auto isa{isa_name(std::move(triple))}; + const std::string isa{isa_name(std::move(triple))}; if (isa.empty()) return hsa_isa_t({}); diff --git a/hipamd/src/device_functions.cpp b/hipamd/src/device_functions.cpp deleted file mode 100644 index 8ef19bab3f..0000000000 --- a/hipamd/src/device_functions.cpp +++ /dev/null @@ -1,387 +0,0 @@ -/* -Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. -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. -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. 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. -*/ - -#include -#include -#include -#include -#include "device_util.h" - -__device__ float __double2float_rd(double x) { return (double)x; } -__device__ float __double2float_rn(double x) { return (double)x; } -__device__ float __double2float_ru(double x) { return (double)x; } -__device__ float __double2float_rz(double x) { return (double)x; } - - -__device__ int __double2hiint(double x) { - static_assert(sizeof(double) == 2 * sizeof(int), ""); - - int tmp[2]; - __builtin_memcpy(tmp, &x, sizeof(tmp)); - - return tmp[1]; -} -__device__ int __double2loint(double x) { - static_assert(sizeof(double) == 2 * sizeof(int), ""); - - int tmp[2]; - __builtin_memcpy(tmp, &x, sizeof(tmp)); - - return tmp[0]; -} - - -__device__ int __double2int_rd(double x) { return (int)x; } -__device__ int __double2int_rn(double x) { return (int)x; } -__device__ int __double2int_ru(double x) { return (int)x; } -__device__ int __double2int_rz(double x) { return (int)x; } - -__device__ long long int __double2ll_rd(double x) { return (long long int)x; } -__device__ long long int __double2ll_rn(double x) { return (long long int)x; } -__device__ long long int __double2ll_ru(double x) { return (long long int)x; } -__device__ long long int __double2ll_rz(double x) { return (long long int)x; } - - -__device__ unsigned int __double2uint_rd(double x) { return (unsigned int)x; } -__device__ unsigned int __double2uint_rn(double x) { return (unsigned int)x; } -__device__ unsigned int __double2uint_ru(double x) { return (unsigned int)x; } -__device__ unsigned int __double2uint_rz(double x) { return (unsigned int)x; } - -__device__ unsigned long long int __double2ull_rd(double x) { return (unsigned long long int)x; } -__device__ unsigned long long int __double2ull_rn(double x) { return (unsigned long long int)x; } -__device__ unsigned long long int __double2ull_ru(double x) { return (unsigned long long int)x; } -__device__ unsigned long long int __double2ull_rz(double x) { return (unsigned long long int)x; } - -__device__ long long int __double_as_longlong(double x) { - static_assert(sizeof(long long) == sizeof(double), ""); - - long long tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} - -__device__ int __float2int_rd(float x) { return (int)__ocml_floor_f32(x); } -__device__ int __float2int_rn(float x) { return (int)__ocml_rint_f32(x); } -__device__ int __float2int_ru(float x) { return (int)__ocml_ceil_f32(x); } -__device__ int __float2int_rz(float x) { return (int)__ocml_trunc_f32(x); } - -__device__ long long int __float2ll_rd(float x) { return (long long int)x; } -__device__ long long int __float2ll_rn(float x) { return (long long int)x; } -__device__ long long int __float2ll_ru(float x) { return (long long int)x; } -__device__ long long int __float2ll_rz(float x) { return (long long int)x; } - -__device__ unsigned int __float2uint_rd(float x) { return (unsigned int)x; } -__device__ unsigned int __float2uint_rn(float x) { return (unsigned int)x; } -__device__ unsigned int __float2uint_ru(float x) { return (unsigned int)x; } -__device__ unsigned int __float2uint_rz(float x) { return (unsigned int)x; } - -__device__ unsigned long long int __float2ull_rd(float x) { return (unsigned long long int)x; } -__device__ unsigned long long int __float2ull_rn(float x) { return (unsigned long long int)x; } -__device__ unsigned long long int __float2ull_ru(float x) { return (unsigned long long int)x; } -__device__ unsigned long long int __float2ull_rz(float x) { return (unsigned long long int)x; } - -__device__ int __float_as_int(float x) { - static_assert(sizeof(int) == sizeof(float), ""); - - int tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} -__device__ unsigned int __float_as_uint(float x) { - static_assert(sizeof(unsigned int) == sizeof(float), ""); - - unsigned int tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} -__device__ double __hiloint2double(int32_t hi, int32_t lo) { - static_assert(sizeof(double) == sizeof(uint64_t), ""); - - uint64_t tmp0 = (static_cast(hi) << 32ull) | static_cast(lo); - double tmp1; - __builtin_memcpy(&tmp1, &tmp0, sizeof(tmp0)); - - return tmp1; -} -__device__ double __int2double_rn(int x) { return (double)x; } - -__device__ float __int2float_rd(int x) { return (float)x; } -__device__ float __int2float_rn(int x) { return (float)x; } -__device__ float __int2float_ru(int x) { return (float)x; } -__device__ float __int2float_rz(int x) { return (float)x; } - -__device__ float __int_as_float(int x) { - static_assert(sizeof(float) == sizeof(int), ""); - - float tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} - -__device__ double __ll2double_rd(long long int x) { return (double)x; } -__device__ double __ll2double_rn(long long int x) { return (double)x; } -__device__ double __ll2double_ru(long long int x) { return (double)x; } -__device__ double __ll2double_rz(long long int x) { return (double)x; } - -__device__ float __ll2float_rd(long long int x) { return (float)x; } -__device__ float __ll2float_rn(long long int x) { return (float)x; } -__device__ float __ll2float_ru(long long int x) { return (float)x; } -__device__ float __ll2float_rz(long long int x) { return (float)x; } - -__device__ double __longlong_as_double(long long int x) { - static_assert(sizeof(double) == sizeof(long long), ""); - - double tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return x; -} - -__device__ double __uint2double_rn(int x) { return (double)x; } - -__device__ float __uint2float_rd(unsigned int x) { return (float)x; } -__device__ float __uint2float_rn(unsigned int x) { return (float)x; } -__device__ float __uint2float_ru(unsigned int x) { return (float)x; } -__device__ float __uint2float_rz(unsigned int x) { return (float)x; } - -__device__ float __uint_as_float(unsigned int x) { - static_assert(sizeof(float) == sizeof(unsigned int), ""); - - float tmp; - __builtin_memcpy(&tmp, &x, sizeof(tmp)); - - return tmp; -} - -__device__ double __ull2double_rd(unsigned long long int x) { return (double)x; } -__device__ double __ull2double_rn(unsigned long long int x) { return (double)x; } -__device__ double __ull2double_ru(unsigned long long int x) { return (double)x; } -__device__ double __ull2double_rz(unsigned long long int x) { return (double)x; } - -__device__ float __ull2float_rd(unsigned long long int x) { return (float)x; } -__device__ float __ull2float_rn(unsigned long long int x) { return (float)x; } -__device__ float __ull2float_ru(unsigned long long int x) { return (float)x; } -__device__ float __ull2float_rz(unsigned long long int x) { return (float)x; } - -/* -Integer Intrinsics -*/ - -// integer intrinsic function __poc __clz __ffs __brev -__device__ unsigned int __popc(unsigned int input) { return hc::__popcount_u32_b32(input); } - -__device__ unsigned int __popcll(unsigned long long int input) { - return hc::__popcount_u32_b64(input); -} - -__device__ unsigned int __clz(unsigned int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 32 : hc::__firstbit_u32_u32(input); -#else - return hc::__firstbit_u32_u32(input); -#endif -} - -__device__ unsigned int __clzll(unsigned long long int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 64 : hc::__firstbit_u32_u64(input); -#else - return hc::__firstbit_u32_u64(input); -#endif -} - -__device__ unsigned int __clz(int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 32 : hc::__firstbit_u32_s32(input); -#else - return hc::__firstbit_u32_s32(input); -#endif -} - -__device__ unsigned int __clzll(long long int input) { -#ifdef NVCC_COMPAT - return input == 0 ? 64 : hc::__firstbit_u32_s64(input); -#else - return hc::__firstbit_u32_s64(input); -#endif -} - -__device__ unsigned int __ffs(unsigned int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_u32(input) + 1; -#else - return hc::__lastbit_u32_u32(input); -#endif -} - -__device__ unsigned int __ffsll(unsigned long long int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_u64(input) + 1; -#else - return hc::__lastbit_u32_u64(input); -#endif -} - -__device__ unsigned int __ffs(int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_s32(input) + 1; -#else - return hc::__lastbit_u32_s32(input); -#endif -} - -__device__ unsigned int __ffsll(long long int input) { -#ifdef NVCC_COMPAT - return hc::__lastbit_u32_s64(input) + 1; -#else - return hc::__lastbit_u32_s64(input); -#endif -} - -__device__ unsigned int __brev(unsigned int input) { return hc::__bitrev_b32(input); } - -__device__ unsigned long long int __brevll(unsigned long long int input) { - return hc::__bitrev_b64(input); -} - -struct ucharHolder { - union { - unsigned char c[4]; - unsigned int ui; - }; -} __attribute__((aligned(4))); - -struct uchar2Holder { - union { - unsigned int ui[2]; - unsigned char c[8]; - }; -} __attribute__((aligned(8))); - -__device__ unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s) { - struct uchar2Holder cHoldVal; - struct ucharHolder cHoldKey; - struct ucharHolder cHoldOut; - cHoldKey.ui = s; - cHoldVal.ui[0] = x; - cHoldVal.ui[1] = y; - cHoldOut.c[0] = cHoldVal.c[cHoldKey.c[0]]; - cHoldOut.c[1] = cHoldVal.c[cHoldKey.c[1]]; - cHoldOut.c[2] = cHoldVal.c[cHoldKey.c[2]]; - cHoldOut.c[3] = cHoldVal.c[cHoldKey.c[3]]; - return cHoldOut.ui; -} - -__device__ long long __mul64hi(long long int x, long long int y) { - ulong x0 = (ulong)x & 0xffffffffUL; - long x1 = x >> 32; - ulong y0 = (ulong)y & 0xffffffffUL; - long y1 = y >> 32; - ulong z0 = x0*y0; - long t = x1*y0 + (z0 >> 32); - long z1 = t & 0xffffffffL; - long z2 = t >> 32; - z1 = x0*y1 + z1; - return x1*y1 + z2 + (z1 >> 32); -} - -__device__ unsigned long long __umul64hi(unsigned long long int x, unsigned long long int y) { - ulong x0 = x & 0xffffffffUL; - ulong x1 = x >> 32; - ulong y0 = y & 0xffffffffUL; - ulong y1 = y >> 32; - ulong z0 = x0*y0; - ulong t = x1*y0 + (z0 >> 32); - ulong z1 = t & 0xffffffffUL; - ulong z2 = t >> 32; - z1 = x0*y1 + z1; - return x1*y1 + z2 + (z1 >> 32); -} - -/* -HIP specific device functions -*/ - -__device__ unsigned __hip_ds_bpermute(int index, unsigned src) { - return hc::__amdgcn_ds_bpermute(index, src); -} - -__device__ float __hip_ds_bpermutef(int index, float src) { - return hc::__amdgcn_ds_bpermute(index, src); -} - -__device__ unsigned __hip_ds_permute(int index, unsigned src) { - return hc::__amdgcn_ds_permute(index, src); -} - -__device__ float __hip_ds_permutef(int index, float src) { - return hc::__amdgcn_ds_permute(index, src); -} - -__device__ unsigned __hip_ds_swizzle(unsigned int src, int pattern) { - return hc::__amdgcn_ds_swizzle(src, pattern); -} - -__device__ float __hip_ds_swizzlef(float src, int pattern) { - return hc::__amdgcn_ds_swizzle(src, pattern); -} - -__device__ int __hip_move_dpp(int src, int dpp_ctrl, int row_mask, int bank_mask, bool bound_ctrl) { - return hc::__amdgcn_move_dpp(src, dpp_ctrl, row_mask, bank_mask, bound_ctrl); -} - -#define MASK1 0x00ff00ff -#define MASK2 0xff00ff00 - -__device__ char4 __hip_hc_add8pk(char4 in1, char4 in2) { - char4 out; - unsigned one1 = in1.a & MASK1; - unsigned one2 = in2.a & MASK1; - out.a = (one1 + one2) & MASK1; - one1 = in1.a & MASK2; - one2 = in2.a & MASK2; - out.a = out.a | ((one1 + one2) & MASK2); - return out; -} - -__device__ char4 __hip_hc_sub8pk(char4 in1, char4 in2) { - char4 out; - unsigned one1 = in1.a & MASK1; - unsigned one2 = in2.a & MASK1; - out.a = (one1 - one2) & MASK1; - one1 = in1.a & MASK2; - one2 = in2.a & MASK2; - out.a = out.a | ((one1 - one2) & MASK2); - return out; -} - -__device__ char4 __hip_hc_mul8pk(char4 in1, char4 in2) { - char4 out; - unsigned one1 = in1.a & MASK1; - unsigned one2 = in2.a & MASK1; - out.a = (one1 * one2) & MASK1; - one1 = in1.a & MASK2; - one2 = in2.a & MASK2; - out.a = out.a | ((one1 * one2) & MASK2); - return out; -} diff --git a/hipamd/src/device_util.cpp b/hipamd/src/device_util.cpp index 5f37e0dab4..87fbe0fcbc 100644 --- a/hipamd/src/device_util.cpp +++ b/hipamd/src/device_util.cpp @@ -92,70 +92,7 @@ __device__ void* __hip_hc_free(void* ptr) { return nullptr; } -__device__ long long int clock64() { return (long long int)hc::__cycle_u64(); }; -__device__ clock_t clock() { return (clock_t)hc::__cycle_u64(); }; - // abort __device__ void abort() { return hc::abort(); } -// warp vote function __all __any __ballot -__device__ int __all(int input) { return hc::__all(input); } - - -__device__ int __any(int input) { -#ifdef NVCC_COMPAT - if (hc::__any(input) != 0) - return 1; - else - return 0; -#else - return hc::__any(input); -#endif -} - -__device__ unsigned long long int __ballot(int input) { return hc::__ballot(input); } - -// warp shuffle functions -__device__ int __shfl(int input, int lane, int width) { return hc::__shfl(input, lane, width); } - -__device__ int __shfl_up(int input, unsigned int lane_delta, int width) { - return hc::__shfl_up(input, lane_delta, width); -} - -__device__ int __shfl_down(int input, unsigned int lane_delta, int width) { - return hc::__shfl_down(input, lane_delta, width); -} - -__device__ int __shfl_xor(int input, int lane_mask, int width) { - return hc::__shfl_xor(input, lane_mask, width); -} - -__device__ float __shfl(float input, int lane, int width) { return hc::__shfl(input, lane, width); } - -__device__ float __shfl_up(float input, unsigned int lane_delta, int width) { - return hc::__shfl_up(input, lane_delta, width); -} - -__device__ float __shfl_down(float input, unsigned int lane_delta, int width) { - return hc::__shfl_down(input, lane_delta, width); -} - -__device__ float __shfl_xor(float input, int lane_mask, int width) { - return hc::__shfl_xor(input, lane_mask, width); -} - -__host__ __device__ int min(int arg1, int arg2) { - return (int)(hc::precise_math::fmin((float)arg1, (float)arg2)); -} -__host__ __device__ int max(int arg1, int arg2) { - return (int)(hc::precise_math::fmax((float)arg1, (float)arg2)); -} - -__device__ void* __get_dynamicgroupbaseptr() { - return hc::get_dynamic_group_segment_base_pointer(); -} - __host__ void* __get_dynamicgroupbaseptr() { return nullptr; } - - -__device__ void __threadfence_system(void) { std::atomic_thread_fence(std::memory_order_seq_cst); } \ No newline at end of file diff --git a/hipamd/src/device_util.h b/hipamd/src/device_util.h index 6603689d82..8fa96da9d9 100644 --- a/hipamd/src/device_util.h +++ b/hipamd/src/device_util.h @@ -125,7 +125,6 @@ __device__ double __hip_fast_dsqrt_rd(double x); __device__ double __hip_fast_dsqrt_rn(double x); __device__ double __hip_fast_dsqrt_ru(double x); __device__ double __hip_fast_dsqrt_rz(double x); -__device__ void __threadfence_system(void); float __hip_host_j0f(float x); double __hip_host_j0(double x); diff --git a/hipamd/src/hip_hc.ll b/hipamd/src/hip_hc.ll deleted file mode 100644 index aba9205912..0000000000 --- a/hipamd/src/hip_hc.ll +++ /dev/null @@ -1,30 +0,0 @@ -target datalayout = "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64" -target triple = "amdgcn--amdhsa" - -define i32 @__hip_hc_ir_mul24_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_i32_i24 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_umul24_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_u32_u24 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_mulhi_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_hi_i32 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_umulhi_int(i32 %a, i32 %b) #1 { - %1 = tail call i32 asm sideeffect "v_mul_hi_u32 $0, $1, $2","=v,v,v"(i32 %a, i32 %b) - ret i32 %1 -} - -define i32 @__hip_hc_ir_usad_int(i32 %a, i32 %b, i32 %c) #1 { - %1 = tail call i32 asm sideeffect "v_sad_u32 $0, $1, $2, $3","=v,v,v,v"(i32 %a, i32 %b, i32 %c) - ret i32 %1 -} - -attributes #1 = { alwaysinline nounwind } - diff --git a/hipamd/src/hip_ldg.cpp b/hipamd/src/hip_ldg.cpp deleted file mode 100644 index bf94c05571..0000000000 --- a/hipamd/src/hip_ldg.cpp +++ /dev/null @@ -1,83 +0,0 @@ -/* -Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved. - -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. - -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. 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. -*/ - -#include "hip/hcc_detail/hip_ldg.h" -#include "hip/hcc_detail/hip_vector_types.h" - -__device__ char __ldg(const char* ptr) { return *ptr; } - -__device__ char2 __ldg(const char2* ptr) { return *ptr; } - -__device__ char4 __ldg(const char4* ptr) { return *ptr; } - -__device__ signed char __ldg(const signed char* ptr) { return ptr[0]; } - -__device__ unsigned char __ldg(const unsigned char* ptr) { return ptr[0]; } - -__device__ short __ldg(const short* ptr) { return ptr[0]; } - -__device__ short2 __ldg(const short2* ptr) { return ptr[0]; } - -__device__ short4 __ldg(const short4* ptr) { return ptr[0]; } - -__device__ unsigned short __ldg(const unsigned short* ptr) { return ptr[0]; } - -__device__ int __ldg(const int* ptr) { return ptr[0]; } - -__device__ int2 __ldg(const int2* ptr) { return ptr[0]; } - -__device__ int4 __ldg(const int4* ptr) { return ptr[0]; } - -__device__ unsigned int __ldg(const unsigned int* ptr) { return ptr[0]; } - - -__device__ long __ldg(const long* ptr) { return ptr[0]; } - -__device__ unsigned long __ldg(const unsigned long* ptr) { return ptr[0]; } - -__device__ long long __ldg(const long long* ptr) { return ptr[0]; } - -__device__ longlong2 __ldg(const longlong2* ptr) { return ptr[0]; } - -__device__ unsigned long long __ldg(const unsigned long long* ptr) { return ptr[0]; } - -__device__ uchar2 __ldg(const uchar2* ptr) { return ptr[0]; } - -__device__ uchar4 __ldg(const uchar4* ptr) { return ptr[0]; } - -__device__ ushort2 __ldg(const ushort2* ptr) { return ptr[0]; } - -__device__ uint2 __ldg(const uint2* ptr) { return ptr[0]; } - -__device__ uint4 __ldg(const uint4* ptr) { return ptr[0]; } - -__device__ ulonglong2 __ldg(const ulonglong2* ptr) { return ptr[0]; } - -__device__ float __ldg(const float* ptr) { return ptr[0]; } - -__device__ float2 __ldg(const float2* ptr) { return ptr[0]; } - -__device__ float4 __ldg(const float4* ptr) { return ptr[0]; } - -__device__ double __ldg(const double* ptr) { return ptr[0]; } - -__device__ double2 __ldg(const double2* ptr) { return ptr[0]; } diff --git a/hipamd/src/hip_memory.cpp b/hipamd/src/hip_memory.cpp index 787e49683b..d6c04ae98c 100644 --- a/hipamd/src/hip_memory.cpp +++ b/hipamd/src/hip_memory.cpp @@ -1680,12 +1680,9 @@ hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t sp actualDest = pinnedPtr; } } -#if 0 if((width == dpitch) && (width == spitch)) { hip_internal::memcpyAsync(dst, src, width*height, kind, stream); - } else -#endif - { + } else { try { if(!isLocked){ for (int i = 0; i < height; ++i) diff --git a/hipamd/src/hip_texture.cpp b/hipamd/src/hip_texture.cpp index 24c6eef3af..d6caf853de 100644 --- a/hipamd/src/hip_texture.cpp +++ b/hipamd/src/hip_texture.cpp @@ -389,7 +389,8 @@ hipError_t ihipBindTextureImpl(int dim, enum hipTextureReadMode readMode, size_t enum hipTextureFilterMode filterMode = tex->filterMode; int normalizedCoords = tex->normalized; hipTextureObject_t& textureObject = tex->textureObject; - *offset = 0; + if(offset != nullptr) + *offset = 0; auto ctx = ihipGetTlsDefaultCtx(); if (ctx) { hc::accelerator acc = ctx->getDevice()->_acc; @@ -459,7 +460,8 @@ hipError_t ihipBindTexture2DImpl(int dim, enum hipTextureReadMode readMode, size enum hipTextureFilterMode filterMode = tex->filterMode; int normalizedCoords = tex->normalized; hipTextureObject_t& textureObject = tex->textureObject; - *offset = 0; + if(offset != nullptr) + *offset = 0; auto ctx = ihipGetTlsDefaultCtx(); if (ctx) { hc::accelerator acc = ctx->getDevice()->_acc; diff --git a/hipamd/tests/src/deviceLib/hipVectorTypes.cpp b/hipamd/tests/src/deviceLib/hipVectorTypes.cpp index da9e24d079..734878b516 100644 --- a/hipamd/tests/src/deviceLib/hipVectorTypes.cpp +++ b/hipamd/tests/src/deviceLib/hipVectorTypes.cpp @@ -26,7832 +26,174 @@ THE SOFTWARE. * HIT_END */ -#include -#include #include + +#include "vector_test_common.h" #include "test_common.h" -#define cmpVal1(in, exp) \ - if (in.x != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << std::endl; \ - assert(-1); \ - } -#define cmpVal2(in, exp) \ - if (in.x != exp || in.y != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << "," << in.y \ - << std::endl; \ - assert(-1); \ - } +#include +#include +#include +#include -#define cmpVal3(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << "," << in.y << "," \ - << in.z << std::endl; \ - assert(-1); \ - } +using namespace std; -#define cmpVal4(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp || in.w != exp) { \ - std::cout << "Failed at: " << __LINE__ << " in func: " << __func__ \ - << " expected output: " << exp << " but got: " << in.x << "," << in.y << "," \ - << in.z << "," << in.w << std::endl; \ - assert(-1); \ - } +bool integer_unary_tests(...) { + return true; +} -bool TestUChar1() { - uchar1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); +bool integer_binary_tests(...) { + return true; +} - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_unary_tests(V& f1, V& f2) { f1 %= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; f1 &= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; f1 |= f2; - cmpVal1(f1, 1); + if (f1 != V{1}) return false; f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; + if (f1 != V{0}) return false; + f1 = V{1}; f1 <<= f2; - cmpVal1(f1, 2); + if (f1 != V{2}) return false; f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - + if (f1 != V{1}) return false; f2 = ~f1; - cmpVal1(f2, 253); - assert(!f1 == false); - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - uchar1 fa((unsigned char)1); - uchar1 fb((signed char)1); - uchar1 fc((unsigned short)1); - uchar1 fd((signed short)1); - uchar1 fe((unsigned int)1); - uchar1 fg((signed int)1); - uchar1 fh((float)1); - uchar1 fi((double)1); - uchar1 fj((unsigned long)1); - uchar1 fk((signed long)1); - uchar1 fl((unsigned long long)1); - uchar1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; + return f2 == V{~1}; } -bool TestUChar2() { - uchar2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_binary_tests(V& f1, V& f2, V& f3) { f3 = f1 % f2; - cmpVal2(f3, 0); + if (f3 != V{0}) return false; f1 = f3 & f2; - cmpVal2(f1, 0); + if (f1 != V{0}) return false; f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; + if (f2 != V{0}) return false; + f1 = V{1}; + f2 = V{2}; f3 = f1 << f2; - cmpVal2(f3, 4); + if (f3 != V{4}) return false; f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - uchar2 fa1((unsigned char)1); - uchar2 fa2((unsigned char)1, (unsigned char)1); - uchar2 fb1((signed char)1); - uchar2 fb2((signed char)1, (signed char)1); - uchar2 fc1((unsigned short)1); - uchar2 fc2((unsigned short)1, (unsigned short)1); - uchar2 fd1((signed short)1); - uchar2 fd2((signed short)1, (signed short)1); - uchar2 fe1((unsigned int)1); - uchar2 fe2((unsigned int)1, (unsigned int)1); - uchar2 fg1((signed int)1); - uchar2 fg2((signed int)1, (signed int)1); - uchar2 fh1((float)1); - uchar2 fh2((float)1, (float)1); - uchar2 fi1((double)1); - uchar2 fi2((double)1, (double)1); - uchar2 fj1((unsigned long)1); - uchar2 fj2((unsigned long)1, (unsigned long)1); - uchar2 fk1((signed long)1); - uchar2 fk2((signed long)1, (signed long)1); - uchar2 fl1((unsigned long long)1); - uchar2 fl2((unsigned long long)1, (unsigned long long)1); - uchar2 fm1((signed long long)1); - uchar2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; + return f2 == V{2}; } -bool TestUChar3() { - uchar3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - uchar3 fa1((unsigned char)1); - uchar3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - uchar3 fb1((signed char)1); - uchar3 fb2((signed char)1, (signed char)1, (signed char)1); - uchar3 fc1((unsigned short)1); - uchar3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - uchar3 fd1((signed short)1); - uchar3 fd2((signed short)1, (signed short)1, (signed short)1); - uchar3 fe1((unsigned int)1); - uchar3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - uchar3 fg1((signed int)1); - uchar3 fg2((signed int)1, (signed int)1, (signed int)1); - uchar3 fh1((float)1); - uchar3 fh2((float)1, (float)1, (float)1); - uchar3 fi1((double)1); - uchar3 fi2((double)1, (double)1, (double)1); - uchar3 fj1((unsigned long)1); - uchar3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - uchar3 fk1((signed long)1); - uchar3 fk2((signed long)1, (signed long)1, (signed long)1); - uchar3 fl1((unsigned long long)1); - uchar3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - uchar3 fm1((signed long long)1); - uchar3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUChar4() { - uchar4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - - uchar4 fa1((unsigned char)1); - uchar4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - uchar4 fb1((signed char)1); - uchar4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - uchar4 fc1((unsigned short)1); - uchar4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - uchar4 fd1((signed short)1); - uchar4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - uchar4 fe1((unsigned int)1); - uchar4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - uchar4 fg1((signed int)1); - uchar4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - uchar4 fh1((float)1); - uchar4 fh2((float)1, (float)1, (float)1, (float)1); - uchar4 fi1((double)1); - uchar4 fi2((double)1, (double)1, (double)1, (double)1); - uchar4 fj1((unsigned long)1); - uchar4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - uchar4 fk1((signed long)1); - uchar4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - uchar4 fl1((unsigned long long)1); - uchar4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - uchar4 fm1((signed long long)1); - uchar4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestChar1() { - char1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - char1 fa((unsigned char)1); - char1 fb((signed char)1); - char1 fc((unsigned short)1); - char1 fd((signed short)1); - char1 fe((unsigned int)1); - char1 fg((signed int)1); - char1 fh((float)1); - char1 fi((double)1); - char1 fj((unsigned long)1); - char1 fk((signed long)1); - char1 fl((unsigned long long)1); - char1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestChar2() { - char2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - char2 fa1((unsigned char)1); - char2 fa2((unsigned char)1, (unsigned char)1); - char2 fb1((signed char)1); - char2 fb2((signed char)1, (signed char)1); - char2 fc1((unsigned short)1); - char2 fc2((unsigned short)1, (unsigned short)1); - char2 fd1((signed short)1); - char2 fd2((signed short)1, (signed short)1); - char2 fe1((unsigned int)1); - char2 fe2((unsigned int)1, (unsigned int)1); - char2 fg1((signed int)1); - char2 fg2((signed int)1, (signed int)1); - char2 fh1((float)1); - char2 fh2((float)1, (float)1); - char2 fi1((double)1); - char2 fi2((double)1, (double)1); - char2 fj1((unsigned long)1); - char2 fj2((unsigned long)1, (unsigned long)1); - char2 fk1((signed long)1); - char2 fk2((signed long)1, (signed long)1); - char2 fl1((unsigned long long)1); - char2 fl2((unsigned long long)1, (unsigned long long)1); - char2 fm1((signed long long)1); - char2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestChar3() { - char3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - char3 fa1((unsigned char)1); - char3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - char3 fb1((signed char)1); - char3 fb2((signed char)1, (signed char)1, (signed char)1); - char3 fc1((unsigned short)1); - char3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - char3 fd1((signed short)1); - char3 fd2((signed short)1, (signed short)1, (signed short)1); - char3 fe1((unsigned int)1); - char3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - char3 fg1((signed int)1); - char3 fg2((signed int)1, (signed int)1, (signed int)1); - char3 fh1((float)1); - char3 fh2((float)1, (float)1, (float)1); - char3 fi1((double)1); - char3 fi2((double)1, (double)1, (double)1); - char3 fj1((unsigned long)1); - char3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - char3 fk1((signed long)1); - char3 fk2((signed long)1, (signed long)1, (signed long)1); - char3 fl1((unsigned long long)1); - char3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - char3 fm1((signed long long)1); - char3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestChar4() { - char4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (char)253); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - char4 fa1((unsigned char)1); - char4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - char4 fb1((signed char)1); - char4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - char4 fc1((unsigned short)1); - char4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - char4 fd1((signed short)1); - char4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - char4 fe1((unsigned int)1); - char4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - char4 fg1((signed int)1); - char4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - char4 fh1((float)1); - char4 fh2((float)1, (float)1, (float)1, (float)1); - char4 fi1((double)1); - char4 fi2((double)1, (double)1, (double)1, (double)1); - char4 fj1((unsigned long)1); - char4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - char4 fk1((signed long)1); - char4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - char4 fl1((unsigned long long)1); - char4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - char4 fm1((signed long long)1); - char4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestUShort1() { - ushort1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - ushort1 fa((unsigned char)1); - ushort1 fb((signed char)1); - ushort1 fc((unsigned short)1); - ushort1 fd((signed short)1); - ushort1 fe((unsigned int)1); - ushort1 fg((signed int)1); - ushort1 fh((float)1); - ushort1 fi((double)1); - ushort1 fj((unsigned long)1); - ushort1 fk((signed long)1); - ushort1 fl((unsigned long long)1); - ushort1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUShort2() { - ushort2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - ushort2 fa1((unsigned char)1); - ushort2 fa2((unsigned char)1, (unsigned char)1); - ushort2 fb1((signed char)1); - ushort2 fb2((signed char)1, (signed char)1); - ushort2 fc1((unsigned short)1); - ushort2 fc2((unsigned short)1, (unsigned short)1); - ushort2 fd1((signed short)1); - ushort2 fd2((signed short)1, (signed short)1); - ushort2 fe1((unsigned int)1); - ushort2 fe2((unsigned int)1, (unsigned int)1); - ushort2 fg1((signed int)1); - ushort2 fg2((signed int)1, (signed int)1); - ushort2 fh1((float)1); - ushort2 fh2((float)1, (float)1); - ushort2 fi1((double)1); - ushort2 fi2((double)1, (double)1); - ushort2 fj1((unsigned long)1); - ushort2 fj2((unsigned long)1, (unsigned long)1); - ushort2 fk1((signed long)1); - ushort2 fk2((signed long)1, (signed long)1); - ushort2 fl1((unsigned long long)1); - ushort2 fl2((unsigned long long)1, (unsigned long long)1); - ushort2 fm1((signed long long)1); - ushort2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUShort3() { - ushort3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - ushort3 fa1((unsigned char)1); - ushort3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - ushort3 fb1((signed char)1); - ushort3 fb2((signed char)1, (signed char)1, (signed char)1); - ushort3 fc1((unsigned short)1); - ushort3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - ushort3 fd1((signed short)1); - ushort3 fd2((signed short)1, (signed short)1, (signed short)1); - ushort3 fe1((unsigned int)1); - ushort3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - ushort3 fg1((signed int)1); - ushort3 fg2((signed int)1, (signed int)1, (signed int)1); - ushort3 fh1((float)1); - ushort3 fh2((float)1, (float)1, (float)1); - ushort3 fi1((double)1); - ushort3 fi2((double)1, (double)1, (double)1); - ushort3 fj1((unsigned long)1); - ushort3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - ushort3 fk1((signed long)1); - ushort3 fk2((signed long)1, (signed long)1, (signed long)1); - ushort3 fl1((unsigned long long)1); - ushort3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - ushort3 fm1((signed long long)1); - ushort3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUShort4() { - ushort4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - ushort4 fa1((unsigned char)1); - ushort4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - ushort4 fb1((signed char)1); - ushort4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - ushort4 fc1((unsigned short)1); - ushort4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - ushort4 fd1((signed short)1); - ushort4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - ushort4 fe1((unsigned int)1); - ushort4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - ushort4 fg1((signed int)1); - ushort4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - ushort4 fh1((float)1); - ushort4 fh2((float)1, (float)1, (float)1, (float)1); - ushort4 fi1((double)1); - ushort4 fi2((double)1, (double)1, (double)1, (double)1); - ushort4 fj1((unsigned long)1); - ushort4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - ushort4 fk1((signed long)1); - ushort4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - ushort4 fl1((unsigned long long)1); - ushort4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - ushort4 fm1((signed long long)1); - ushort4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestShort1() { - short1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed short)65533); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - short1 fa((unsigned char)1); - short1 fb((signed char)1); - short1 fc((unsigned short)1); - short1 fd((signed short)1); - short1 fe((unsigned int)1); - short1 fg((signed int)1); - short1 fh((float)1); - short1 fi((double)1); - short1 fj((unsigned long)1); - short1 fk((signed long)1); - short1 fl((unsigned long long)1); - short1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestShort2() { - short2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed short)65533); - assert(!f1 == false); - - cmpVal2(f1, 3); - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - short2 fa1((unsigned char)1); - short2 fa2((unsigned char)1, (unsigned char)1); - short2 fb1((signed char)1); - short2 fb2((signed char)1, (signed char)1); - short2 fc1((unsigned short)1); - short2 fc2((unsigned short)1, (unsigned short)1); - short2 fd1((signed short)1); - short2 fd2((signed short)1, (signed short)1); - short2 fe1((unsigned int)1); - short2 fe2((unsigned int)1, (unsigned int)1); - short2 fg1((signed int)1); - short2 fg2((signed int)1, (signed int)1); - short2 fh1((float)1); - short2 fh2((float)1, (float)1); - short2 fi1((double)1); - short2 fi2((double)1, (double)1); - short2 fj1((unsigned long)1); - short2 fj2((unsigned long)1, (unsigned long)1); - short2 fk1((signed long)1); - short2 fk2((signed long)1, (signed long)1); - short2 fl1((unsigned long long)1); - short2 fl2((unsigned long long)1, (unsigned long long)1); - short2 fm1((signed long long)1); - short2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestShort3() { - short3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - short3 fa1((unsigned char)1); - short3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - short3 fb1((signed char)1); - short3 fb2((signed char)1, (signed char)1, (signed char)1); - short3 fc1((unsigned short)1); - short3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - short3 fd1((signed short)1); - short3 fd2((signed short)1, (signed short)1, (signed short)1); - short3 fe1((unsigned int)1); - short3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - short3 fg1((signed int)1); - short3 fg2((signed int)1, (signed int)1, (signed int)1); - short3 fh1((float)1); - short3 fh2((float)1, (float)1, (float)1); - short3 fi1((double)1); - short3 fi2((double)1, (double)1, (double)1); - short3 fj1((unsigned long)1); - short3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - short3 fk1((signed long)1); - short3 fk2((signed long)1, (signed long)1, (signed long)1); - short3 fl1((unsigned long long)1); - short3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - short3 fm1((signed long long)1); - short3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestShort4() { - short4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed short)65533); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - short4 fa1((unsigned char)1); - short4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - short4 fb1((signed char)1); - short4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - short4 fc1((unsigned short)1); - short4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - short4 fd1((signed short)1); - short4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - short4 fe1((unsigned int)1); - short4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - short4 fg1((signed int)1); - short4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - short4 fh1((float)1); - short4 fh2((float)1, (float)1, (float)1, (float)1); - short4 fi1((double)1); - short4 fi2((double)1, (double)1, (double)1, (double)1); - short4 fj1((unsigned long)1); - short4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - short4 fk1((signed long)1); - short4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - short4 fl1((unsigned long long)1); - short4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - short4 fm1((signed long long)1); - short4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestUInt1() { - uint1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - uint1 fa((unsigned char)1); - uint1 fb((signed char)1); - uint1 fc((unsigned short)1); - uint1 fd((signed short)1); - uint1 fe((unsigned int)1); - uint1 fg((signed int)1); - uint1 fh((float)1); - uint1 fi((double)1); - uint1 fj((unsigned long)1); - uint1 fk((signed long)1); - uint1 fl((unsigned long long)1); - uint1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUInt2() { - uint2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - uint2 fa1((unsigned char)1); - uint2 fa2((unsigned char)1, (unsigned char)1); - uint2 fb1((signed char)1); - uint2 fb2((signed char)1, (signed char)1); - uint2 fc1((unsigned short)1); - uint2 fc2((unsigned short)1, (unsigned short)1); - uint2 fd1((signed short)1); - uint2 fd2((signed short)1, (signed short)1); - uint2 fe1((unsigned int)1); - uint2 fe2((unsigned int)1, (unsigned int)1); - uint2 fg1((signed int)1); - uint2 fg2((signed int)1, (signed int)1); - uint2 fh1((float)1); - uint2 fh2((float)1, (float)1); - uint2 fi1((double)1); - uint2 fi2((double)1, (double)1); - uint2 fj1((unsigned long)1); - uint2 fj2((unsigned long)1, (unsigned long)1); - uint2 fk1((signed long)1); - uint2 fk2((signed long)1, (signed long)1); - uint2 fl1((unsigned long long)1); - uint2 fl2((unsigned long long)1, (unsigned long long)1); - uint2 fm1((signed long long)1); - uint2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUInt3() { - uint3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - uint3 fa1((unsigned char)1); - uint3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - uint3 fb1((signed char)1); - uint3 fb2((signed char)1, (signed char)1, (signed char)1); - uint3 fc1((unsigned short)1); - uint3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - uint3 fd1((signed short)1); - uint3 fd2((signed short)1, (signed short)1, (signed short)1); - uint3 fe1((unsigned int)1); - uint3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - uint3 fg1((signed int)1); - uint3 fg2((signed int)1, (signed int)1, (signed int)1); - uint3 fh1((float)1); - uint3 fh2((float)1, (float)1, (float)1); - uint3 fi1((double)1); - uint3 fi2((double)1, (double)1, (double)1); - uint3 fj1((unsigned long)1); - uint3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - uint3 fk1((signed long)1); - uint3 fk2((signed long)1, (signed long)1, (signed long)1); - uint3 fl1((unsigned long long)1); - uint3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - uint3 fm1((signed long long)1); - uint3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestUInt4() { - uint4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - uint4 fa1((unsigned char)1); - uint4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - uint4 fb1((signed char)1); - uint4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - uint4 fc1((unsigned short)1); - uint4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - uint4 fd1((signed short)1); - uint4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - uint4 fe1((unsigned int)1); - uint4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - uint4 fg1((signed int)1); - uint4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - uint4 fh1((float)1); - uint4 fh2((float)1, (float)1, (float)1, (float)1); - uint4 fi1((double)1); - uint4 fi2((double)1, (double)1, (double)1, (double)1); - uint4 fj1((unsigned long)1); - uint4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - uint4 fk1((signed long)1); - uint4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - uint4 fl1((unsigned long long)1); - uint4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - uint4 fm1((signed long long)1); - uint4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestInt1() { - int1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - int1 fa((unsigned char)1); - int1 fb((signed char)1); - int1 fc((unsigned short)1); - int1 fd((signed short)1); - int1 fe((unsigned int)1); - int1 fg((signed int)1); - int1 fh((float)1); - int1 fi((double)1); - int1 fj((unsigned long)1); - int1 fk((signed long)1); - int1 fl((unsigned long long)1); - int1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestInt2() { - int2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - int2 fa1((unsigned char)1); - int2 fa2((unsigned char)1, (unsigned char)1); - int2 fb1((signed char)1); - int2 fb2((signed char)1, (signed char)1); - int2 fc1((unsigned short)1); - int2 fc2((unsigned short)1, (unsigned short)1); - int2 fd1((signed short)1); - int2 fd2((signed short)1, (signed short)1); - int2 fe1((unsigned int)1); - int2 fe2((unsigned int)1, (unsigned int)1); - int2 fg1((signed int)1); - int2 fg2((signed int)1, (signed int)1); - int2 fh1((float)1); - int2 fh2((float)1, (float)1); - int2 fi1((double)1); - int2 fi2((double)1, (double)1); - int2 fj1((unsigned long)1); - int2 fj2((unsigned long)1, (unsigned long)1); - int2 fk1((signed long)1); - int2 fk2((signed long)1, (signed long)1); - int2 fl1((unsigned long long)1); - int2 fl2((unsigned long long)1, (unsigned long long)1); - int2 fm1((signed long long)1); - int2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestInt3() { - int3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - int3 fa1((unsigned char)1); - int3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - int3 fb1((signed char)1); - int3 fb2((signed char)1, (signed char)1, (signed char)1); - int3 fc1((unsigned short)1); - int3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - int3 fd1((signed short)1); - int3 fd2((signed short)1, (signed short)1, (signed short)1); - int3 fe1((unsigned int)1); - int3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - int3 fg1((signed int)1); - int3 fg2((signed int)1, (signed int)1, (signed int)1); - int3 fh1((float)1); - int3 fh2((float)1, (float)1, (float)1); - int3 fi1((double)1); - int3 fi2((double)1, (double)1, (double)1); - int3 fj1((unsigned long)1); - int3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - int3 fk1((signed long)1); - int3 fk2((signed long)1, (signed long)1, (signed long)1); - int3 fl1((unsigned long long)1); - int3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - int3 fm1((signed long long)1); - int3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestInt4() { - int4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed int)4294967293); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - int4 fa1((unsigned char)1); - int4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - int4 fb1((signed char)1); - int4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - int4 fc1((unsigned short)1); - int4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - int4 fd1((signed short)1); - int4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - int4 fe1((unsigned int)1); - int4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - int4 fg1((signed int)1); - int4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - int4 fh1((float)1); - int4 fh2((float)1, (float)1, (float)1, (float)1); - int4 fi1((double)1); - int4 fi2((double)1, (double)1, (double)1, (double)1); - int4 fj1((unsigned long)1); - int4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - int4 fk1((signed long)1); - int4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - int4 fl1((unsigned long long)1); - int4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - int4 fm1((signed long long)1); - int4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestFloat1() { - float1 f1, f2, f3; - f1.x = 1.0f; - f2.x = 1.0f; - f3 = f1 + f2; - cmpVal1(f3, 2.0f); - f2 = f3 - f1; - cmpVal1(f2, 1.0f); - f1 = f2 * f3; - cmpVal1(f1, 2.0f); - f2 = f1 / f3; - cmpVal1(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal1(f1, 3.0f); - f1 -= f2; - cmpVal1(f1, 2.0f); - f1 *= f2; - cmpVal1(f1, 2.0f); - f1 /= f2; - cmpVal1(f1, 2.0f); - f2 = f1++; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 2.0f); - f2 = f1--; - cmpVal1(f2, 3.0f); - cmpVal1(f1, 2.0f); - f2 = ++f1; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 3.0f); - f2 = --f1; - cmpVal1(f1, 2.0f); - cmpVal1(f1, 2.0f); - - f1.x = 3.0f; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3.0f); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3.0f); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3.0f); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (float)1; - cmpVal1(f1, 3.0f); - f1 = (float)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3.0f); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (double)1; - cmpVal1(f1, 3.0f); - f1 = (double)1 * f1; - cmpVal1(f1, 3.0f); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3.0f); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3.0f); - - float1 fa((unsigned char)1); - float1 fb((signed char)1); - float1 fc((unsigned short)1); - float1 fd((signed short)1); - float1 fe((unsigned int)1); - float1 fg((signed int)1); - float1 fh((float)1); - float1 fi((double)1); - float1 fj((unsigned long)1); - float1 fk((signed long)1); - float1 fl((unsigned long long)1); - float1 fm((signed long long)1); - - - f1.x = 3.0f; - f2.x = 4.0f; - f3.x = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); +template +bool constructor_tests() { + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); + static_assert(is_constructible{}, ""); return true; } -bool TestFloat2() { - float2 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f3 = f1 + f2; - cmpVal2(f3, 2.0f); +template +bool TestVectorType() { + V f1{1}; + V f2{1}; + V f3 = f1 + f2; + if (f3 != V{2}) return false; f2 = f3 - f1; - cmpVal2(f2, 1.0f); + if (f2 != V{1}) return false; f1 = f2 * f3; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; f2 = f1 / f3; - cmpVal2(f2, 2.0f / 2.0f); + if (f2 != V{1}) return false; + if (!integer_binary_tests(f1, f2, f3)) return false; + + f1 = V{2}; + f2 = V{1}; f1 += f2; - cmpVal2(f1, 3.0f); + if (f1 != V{3}) return false; f1 -= f2; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; f1 *= f2; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; f1 /= f2; - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; + if (!integer_unary_tests(f1, f2)) return false; + f1 = V{2}; f2 = f1++; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 2.0f); + if (f1 != V{3}) return false; + if (f2 != V{2}) return false; f2 = f1--; - cmpVal2(f2, 3.0f); - cmpVal2(f1, 2.0f); + if (f2 != V{3}) return false; + if (f1 != V{2}) return false; f2 = ++f1; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 3.0f); + if (f1 != V{3}) return false; + if (f2 != V{3}) return false; f2 = --f1; - cmpVal2(f1, 2.0f); - cmpVal2(f1, 2.0f); + if (f1 != V{2}) return false; + if (f2 != V{2}) return false; - f1.x = 3.0f; - f1.y = 3.0f; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3.0f); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3.0f); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3.0f); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (float)1; - cmpVal2(f1, 3.0f); - f1 = (float)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3.0f); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (double)1; - cmpVal2(f1, 3.0f); - f1 = (double)1 * f1; - cmpVal2(f1, 3.0f); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3.0f); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3.0f); - - float2 fa1((unsigned char)1); - float2 fa2((unsigned char)1, (unsigned char)1); - float2 fb1((signed char)1); - float2 fb2((signed char)1, (signed char)1); - float2 fc1((unsigned short)1); - float2 fc2((unsigned short)1, (unsigned short)1); - float2 fd1((signed short)1); - float2 fd2((signed short)1, (signed short)1); - float2 fe1((unsigned int)1); - float2 fe2((unsigned int)1, (unsigned int)1); - float2 fg1((signed int)1); - float2 fg2((signed int)1, (signed int)1); - float2 fh1((float)1); - float2 fh2((float)1, (float)1); - float2 fi1((double)1); - float2 fi2((double)1, (double)1); - float2 fj1((unsigned long)1); - float2 fj2((unsigned long)1, (unsigned long)1); - float2 fk1((signed long)1); - float2 fk2((signed long)1, (signed long)1); - float2 fl1((unsigned long long)1); - float2 fl2((unsigned long long)1, (unsigned long long)1); - float2 fm1((signed long long)1); - float2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3.0f; - f1.y = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); + if (!constructor_tests()) return false; + f1 = V{3}; + f2 = V{4}; + f3 = V{3}; + if (f1 == f2) return false; + if (!(f1 != f2)) return false; return true; } -bool TestFloat3() { - float3 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f3 = f1 + f2; - cmpVal3(f3, 2.0f); - f2 = f3 - f1; - cmpVal3(f2, 1.0f); - f1 = f2 * f3; - cmpVal3(f1, 2.0f); - f2 = f1 / f3; - cmpVal3(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal3(f1, 3.0f); - f1 -= f2; - cmpVal3(f1, 2.0f); - f1 *= f2; - cmpVal3(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 2.0f); - f2 = f1--; - cmpVal3(f2, 3.0f); - cmpVal3(f1, 2.0f); - f2 = ++f1; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 3.0f); - f2 = --f1; - cmpVal3(f1, 2.0f); - cmpVal3(f1, 2.0f); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - float3 fa1((unsigned char)1); - float3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - float3 fb1((signed char)1); - float3 fb2((signed char)1, (signed char)1, (signed char)1); - float3 fc1((unsigned short)1); - float3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - float3 fd1((signed short)1); - float3 fd2((signed short)1, (signed short)1, (signed short)1); - float3 fe1((unsigned int)1); - float3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - float3 fg1((signed int)1); - float3 fg2((signed int)1, (signed int)1, (signed int)1); - float3 fh1((float)1); - float3 fh2((float)1, (float)1, (float)1); - float3 fi1((double)1); - float3 fi2((double)1, (double)1, (double)1); - float3 fj1((unsigned long)1); - float3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - float3 fk1((signed long)1); - float3 fk2((signed long)1, (signed long)1, (signed long)1); - float3 fl1((unsigned long long)1); - float3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - float3 fm1((signed long long)1); - float3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - +template* = nullptr> +bool TestVectorTypes() { return true; } -bool TestFloat4() { - float4 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f1.w = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f2.w = 1.0f; - f3 = f1 + f2; - cmpVal4(f3, 2.0f); - f2 = f3 - f1; - cmpVal4(f2, 1.0f); - f1 = f2 * f3; - cmpVal4(f1, 2.0f); - f2 = f1 / f3; - cmpVal4(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal4(f1, 3.0f); - f1 -= f2; - cmpVal4(f1, 2.0f); - f1 *= f2; - cmpVal4(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 2.0f); - f2 = f1--; - cmpVal4(f2, 3.0f); - cmpVal4(f1, 2.0f); - f2 = ++f1; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 3.0f); - f2 = --f1; - cmpVal4(f1, 2.0f); - cmpVal4(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f1.w = 3.0f; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3.0f); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3.0f); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3.0f); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (float)1; - cmpVal4(f1, 3.0f); - f1 = (float)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3.0f); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (double)1; - cmpVal4(f1, 3.0f); - f1 = (double)1 * f1; - cmpVal4(f1, 3.0f); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3.0f); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3.0f); - - float4 fa1((unsigned char)1); - float4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - float4 fb1((signed char)1); - float4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - float4 fc1((unsigned short)1); - float4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - float4 fd1((signed short)1); - float4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - float4 fe1((unsigned int)1); - float4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - float4 fg1((signed int)1); - float4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - float4 fh1((float)1); - float4 fh2((float)1, (float)1, (float)1, (float)1); - float4 fi1((double)1); - float4 fi2((double)1, (double)1, (double)1, (double)1); - float4 fj1((unsigned long)1); - float4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - float4 fk1((signed long)1); - float4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - float4 fl1((unsigned long long)1); - float4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - float4 fm1((signed long long)1); - float4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f1.w = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f2.w = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - f3.w = 3.0f; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - return true; +template +bool TestVectorTypes() { + if (!TestVectorType()) return false; + return TestVectorTypes(); } - -bool TestULong1() { - ulong1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - ulong1 fa((unsigned char)1); - ulong1 fb((signed char)1); - ulong1 fc((unsigned short)1); - ulong1 fd((signed short)1); - ulong1 fe((unsigned int)1); - ulong1 fg((signed int)1); - ulong1 fh((float)1); - ulong1 fi((double)1); - ulong1 fj((unsigned long)1); - ulong1 fk((signed long)1); - ulong1 fl((unsigned long long)1); - ulong1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULong2() { - ulong2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - ulong2 fa1((unsigned char)1); - ulong2 fa2((unsigned char)1, (unsigned char)1); - ulong2 fb1((signed char)1); - ulong2 fb2((signed char)1, (signed char)1); - ulong2 fc1((unsigned short)1); - ulong2 fc2((unsigned short)1, (unsigned short)1); - ulong2 fd1((signed short)1); - ulong2 fd2((signed short)1, (signed short)1); - ulong2 fe1((unsigned int)1); - ulong2 fe2((unsigned int)1, (unsigned int)1); - ulong2 fg1((signed int)1); - ulong2 fg2((signed int)1, (signed int)1); - ulong2 fh1((float)1); - ulong2 fh2((float)1, (float)1); - ulong2 fi1((double)1); - ulong2 fi2((double)1, (double)1); - ulong2 fj1((unsigned long)1); - ulong2 fj2((unsigned long)1, (unsigned long)1); - ulong2 fk1((signed long)1); - ulong2 fk2((signed long)1, (signed long)1); - ulong2 fl1((unsigned long long)1); - ulong2 fl2((unsigned long long)1, (unsigned long long)1); - ulong2 fm1((signed long long)1); - ulong2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULong3() { - ulong3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - ulong3 fa1((unsigned char)1); - ulong3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - ulong3 fb1((signed char)1); - ulong3 fb2((signed char)1, (signed char)1, (signed char)1); - ulong3 fc1((unsigned short)1); - ulong3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - ulong3 fd1((signed short)1); - ulong3 fd2((signed short)1, (signed short)1, (signed short)1); - ulong3 fe1((unsigned int)1); - ulong3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - ulong3 fg1((signed int)1); - ulong3 fg2((signed int)1, (signed int)1, (signed int)1); - ulong3 fh1((float)1); - ulong3 fh2((float)1, (float)1, (float)1); - ulong3 fi1((double)1); - ulong3 fi2((double)1, (double)1, (double)1); - ulong3 fj1((unsigned long)1); - ulong3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - ulong3 fk1((signed long)1); - ulong3 fk2((signed long)1, (signed long)1, (signed long)1); - ulong3 fl1((unsigned long long)1); - ulong3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - ulong3 fm1((signed long long)1); - ulong3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULong4() { - ulong4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 18446744073709551613UL); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - ulong4 fa1((unsigned char)1); - ulong4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - ulong4 fb1((signed char)1); - ulong4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - ulong4 fc1((unsigned short)1); - ulong4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - ulong4 fd1((signed short)1); - ulong4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - ulong4 fe1((unsigned int)1); - ulong4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - ulong4 fg1((signed int)1); - ulong4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - ulong4 fh1((float)1); - ulong4 fh2((float)1, (float)1, (float)1, (float)1); - ulong4 fi1((double)1); - ulong4 fi2((double)1, (double)1, (double)1, (double)1); - ulong4 fj1((unsigned long)1); - ulong4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - ulong4 fk1((signed long)1); - ulong4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - ulong4 fl1((unsigned long long)1); - ulong4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - ulong4 fm1((signed long long)1); - ulong4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - long1 fa((unsigned char)1); - long1 fb((signed char)1); - long1 fc((unsigned short)1); - long1 fd((signed short)1); - long1 fe((unsigned int)1); - long1 fg((signed int)1); - long1 fh((float)1); - long1 fi((double)1); - long1 fj((unsigned long)1); - long1 fk((signed long)1); - long1 fl((unsigned long long)1); - long1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - long2 fa1((unsigned char)1); - long2 fa2((unsigned char)1, (unsigned char)1); - long2 fb1((signed char)1); - long2 fb2((signed char)1, (signed char)1); - long2 fc1((unsigned short)1); - long2 fc2((unsigned short)1, (unsigned short)1); - long2 fd1((signed short)1); - long2 fd2((signed short)1, (signed short)1); - long2 fe1((unsigned int)1); - long2 fe2((unsigned int)1, (unsigned int)1); - long2 fg1((signed int)1); - long2 fg2((signed int)1, (signed int)1); - long2 fh1((float)1); - long2 fh2((float)1, (float)1); - long2 fi1((double)1); - long2 fi2((double)1, (double)1); - long2 fj1((unsigned long)1); - long2 fj2((unsigned long)1, (unsigned long)1); - long2 fk1((signed long)1); - long2 fk2((signed long)1, (signed long)1); - long2 fl1((unsigned long long)1); - long2 fl2((unsigned long long)1, (unsigned long long)1); - long2 fm1((signed long long)1); - long2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - - long3 fa1((unsigned char)1); - long3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - long3 fb1((signed char)1); - long3 fb2((signed char)1, (signed char)1, (signed char)1); - long3 fc1((unsigned short)1); - long3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - long3 fd1((signed short)1); - long3 fd2((signed short)1, (signed short)1, (signed short)1); - long3 fe1((unsigned int)1); - long3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - long3 fg1((signed int)1); - long3 fg2((signed int)1, (signed int)1, (signed int)1); - long3 fh1((float)1); - long3 fh2((float)1, (float)1, (float)1); - long3 fi1((double)1); - long3 fi2((double)1, (double)1, (double)1); - long3 fj1((unsigned long)1); - long3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - long3 fk1((signed long)1); - long3 fk2((signed long)1, (signed long)1, (signed long)1); - long3 fl1((unsigned long long)1); - long3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - long3 fm1((signed long long)1); - long3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - long4 fa1((unsigned char)1); - long4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - long4 fb1((signed char)1); - long4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - long4 fc1((unsigned short)1); - long4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - long4 fd1((signed short)1); - long4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - long4 fe1((unsigned int)1); - long4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - long4 fg1((signed int)1); - long4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - long4 fh1((float)1); - long4 fh2((float)1, (float)1, (float)1, (float)1); - long4 fi1((double)1); - long4 fi2((double)1, (double)1, (double)1, (double)1); - long4 fj1((unsigned long)1); - long4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - long4 fk1((signed long)1); - long4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - long4 fl1((unsigned long long)1); - long4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - long4 fm1((signed long long)1); - long4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestDouble1() { - double1 f1, f2, f3; - f1.x = 1.0; - f2.x = 1.0; - f3 = f1 + f2; - cmpVal1(f3, 2.0); - f2 = f3 - f1; - cmpVal1(f2, 1.0); - f1 = f2 * f3; - cmpVal1(f1, 2.0); - f2 = f1 / f3; - cmpVal1(f2, 2.0 / 2.0); - f1 += f2; - cmpVal1(f1, 3.0); - f1 -= f2; - cmpVal1(f1, 2.0); - f1 *= f2; - cmpVal1(f1, 2.0); - f1 /= f2; - cmpVal1(f1, 2.0); - f2 = f1++; - cmpVal1(f1, 3.0); - cmpVal1(f2, 2.0); - f2 = f1--; - cmpVal1(f2, 3.0); - cmpVal1(f1, 2.0); - f2 = ++f1; - cmpVal1(f1, 3.0); - cmpVal1(f2, 3.0); - f2 = --f1; - cmpVal1(f1, 2.0); - cmpVal1(f1, 2.0); - - f1.x = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (float)1; - cmpVal1(f1, 3.0); - f1 = (float)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (double)1; - cmpVal1(f1, 3.0); - f1 = (double)1 * f1; - cmpVal1(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3.0); - - double1 fa((unsigned char)1); - double1 fb((signed char)1); - double1 fc((unsigned short)1); - double1 fd((signed short)1); - double1 fe((unsigned int)1); - double1 fg((signed int)1); - double1 fh((float)1); - double1 fi((double)1); - double1 fj((unsigned long)1); - double1 fk((signed long)1); - double1 fl((unsigned long long)1); - double1 fm((signed long long)1); - - - f1.x = 3.0; - f2.x = 4.0; - f3.x = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - return true; -} - -bool TestDouble2() { - double2 f1, f2, f3; - f1.x = 1.0; - f1.y = 1.0; - f2.x = 1.0; - f2.y = 1.0; - f3 = f1 + f2; - cmpVal2(f3, 2.0); - f2 = f3 - f1; - cmpVal2(f2, 1.0); - f1 = f2 * f3; - cmpVal2(f1, 2.0); - f2 = f1 / f3; - cmpVal2(f2, 2.0f / 2.0); - f1 += f2; - cmpVal2(f1, 3.0); - f1 -= f2; - cmpVal2(f1, 2.0); - f1 *= f2; - cmpVal2(f1, 2.0); - f1 /= f2; - cmpVal2(f1, 2.0); - - f2 = f1++; - cmpVal2(f1, 3.0); - cmpVal2(f2, 2.0); - f2 = f1--; - cmpVal2(f2, 3.0); - cmpVal2(f1, 2.0); - f2 = ++f1; - cmpVal2(f1, 3.0); - cmpVal2(f2, 3.0); - f2 = --f1; - cmpVal2(f1, 2.0); - cmpVal2(f1, 2.0); - - f1.x = 3.0; - f1.y = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (float)1; - cmpVal2(f1, 3.0); - f1 = (float)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (double)1; - cmpVal2(f1, 3.0); - f1 = (double)1 * f1; - cmpVal2(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3.0); - - double2 fa1((unsigned char)1); - double2 fa2((unsigned char)1, (unsigned char)1); - double2 fb1((signed char)1); - double2 fb2((signed char)1, (signed char)1); - double2 fc1((unsigned short)1); - double2 fc2((unsigned short)1, (unsigned short)1); - double2 fd1((signed short)1); - double2 fd2((signed short)1, (signed short)1); - double2 fe1((unsigned int)1); - double2 fe2((unsigned int)1, (unsigned int)1); - double2 fg1((signed int)1); - double2 fg2((signed int)1, (signed int)1); - double2 fh1((float)1); - double2 fh2((float)1, (float)1); - double2 fi1((double)1); - double2 fi2((double)1, (double)1); - double2 fj1((unsigned long)1); - double2 fj2((unsigned long)1, (unsigned long)1); - double2 fk1((signed long)1); - double2 fk2((signed long)1, (signed long)1); - double2 fl1((unsigned long long)1); - double2 fl2((unsigned long long)1, (unsigned long long)1); - double2 fm1((signed long long)1); - double2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3.0; - f1.y = 3.0; - f2.x = 4.0; - f2.y = 4.0; - f3.x = 3.0; - f3.y = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - - return true; -} - -bool TestDouble3() { - double3 f1, f2, f3; - f1.x = 1.0; - f1.y = 1.0; - f1.z = 1.0; - f2.x = 1.0; - f2.y = 1.0; - f2.z = 1.0; - f3 = f1 + f2; - cmpVal3(f3, 2.0); - f2 = f3 - f1; - cmpVal3(f2, 1.0); - f1 = f2 * f3; - cmpVal3(f1, 2.0); - f2 = f1 / f3; - cmpVal3(f2, 2.0f / 2.0); - f1 += f2; - cmpVal3(f1, 3.0); - f1 -= f2; - cmpVal3(f1, 2.0); - f1 *= f2; - cmpVal3(f1, 2.0); - f1 /= f2; - f2 = f1++; - cmpVal3(f1, 3.0); - cmpVal3(f2, 2.0); - f2 = f1--; - cmpVal3(f2, 3.0); - cmpVal3(f1, 2.0); - f2 = ++f1; - cmpVal3(f1, 3.0); - cmpVal3(f2, 3.0); - f2 = --f1; - cmpVal3(f1, 2.0); - cmpVal3(f1, 2.0); - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (float)1; - cmpVal3(f1, 3.0); - f1 = (float)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (double)1; - cmpVal3(f1, 3.0); - f1 = (double)1 * f1; - cmpVal3(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3.0); - - double3 fa1((unsigned char)1); - double3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - double3 fb1((signed char)1); - double3 fb2((signed char)1, (signed char)1, (signed char)1); - double3 fc1((unsigned short)1); - double3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - double3 fd1((signed short)1); - double3 fd2((signed short)1, (signed short)1, (signed short)1); - double3 fe1((unsigned int)1); - double3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - double3 fg1((signed int)1); - double3 fg2((signed int)1, (signed int)1, (signed int)1); - double3 fh1((float)1); - double3 fh2((float)1, (float)1, (float)1); - double3 fi1((double)1); - double3 fi2((double)1, (double)1, (double)1); - double3 fj1((unsigned long)1); - double3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - double3 fk1((signed long)1); - double3 fk2((signed long)1, (signed long)1, (signed long)1); - double3 fl1((unsigned long long)1); - double3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - double3 fm1((signed long long)1); - double3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f2.x = 4.0; - f2.y = 4.0; - f2.z = 4.0; - f3.x = 3.0; - f3.y = 3.0; - f3.z = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - - return true; -} - -bool TestDouble4() { - double4 f1, f2, f3; - f1.x = 1.0; - f1.y = 1.0; - f1.z = 1.0; - f1.w = 1.0; - f2.x = 1.0; - f2.y = 1.0; - f2.z = 1.0; - f2.w = 1.0; - f3 = f1 + f2; - cmpVal4(f3, 2.0); - f2 = f3 - f1; - cmpVal4(f2, 1.0); - f1 = f2 * f3; - cmpVal4(f1, 2.0); - f2 = f1 / f3; - cmpVal4(f2, 2.0f / 2.0); - f1 += f2; - cmpVal4(f1, 3.0); - f1 -= f2; - cmpVal4(f1, 2.0); - f1 *= f2; - cmpVal4(f1, 2.0); - f1 /= f2; - f2 = f1++; - cmpVal4(f1, 3.0); - cmpVal4(f2, 2.0); - f2 = f1--; - cmpVal4(f2, 3.0); - cmpVal4(f1, 2.0); - f2 = ++f1; - cmpVal4(f1, 3.0); - cmpVal4(f2, 3.0); - f2 = --f1; - cmpVal4(f1, 2.0); - cmpVal4(f1, 2.0); - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f1.w = 3.0; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3.0); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3.0); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3.0); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3.0); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3.0); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3.0); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (float)1; - cmpVal4(f1, 3.0); - f1 = (float)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3.0); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3.0); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (double)1; - cmpVal4(f1, 3.0); - f1 = (double)1 * f1; - cmpVal4(f1, 3.0); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3.0); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3.0); - - double4 fa1((unsigned char)1); - double4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - double4 fb1((signed char)1); - double4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - double4 fc1((unsigned short)1); - double4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - double4 fd1((signed short)1); - double4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - double4 fe1((unsigned int)1); - double4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - double4 fg1((signed int)1); - double4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - double4 fh1((float)1); - double4 fh2((float)1, (float)1, (float)1, (float)1); - double4 fi1((double)1); - double4 fi2((double)1, (double)1, (double)1, (double)1); - double4 fj1((unsigned long)1); - double4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - double4 fk1((signed long)1); - double4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - double4 fl1((unsigned long long)1); - double4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - double4 fm1((signed long long)1); - double4 fm2((signed long long)1, (signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3.0; - f1.y = 3.0; - f1.z = 3.0; - f1.w = 3.0; - f2.x = 4.0; - f2.y = 4.0; - f2.z = 4.0; - f2.w = 4.0; - f3.x = 3.0; - f3.y = 3.0; - f3.z = 3.0; - f3.w = 3.0; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - return true; -} - - -bool TestULongLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - ulonglong1 fa((unsigned char)1); - ulonglong1 fb((signed char)1); - ulonglong1 fc((unsigned short)1); - ulonglong1 fd((signed short)1); - ulonglong1 fe((unsigned int)1); - ulonglong1 fg((signed int)1); - ulonglong1 fh((float)1); - ulonglong1 fi((double)1); - ulonglong1 fj((unsigned long)1); - ulonglong1 fk((signed long)1); - ulonglong1 fl((unsigned long long)1); - ulonglong1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULongLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - ulonglong2 fa1((unsigned char)1); - ulonglong2 fa2((unsigned char)1, (unsigned char)1); - ulonglong2 fb1((signed char)1); - ulonglong2 fb2((signed char)1, (signed char)1); - ulonglong2 fc1((unsigned short)1); - ulonglong2 fc2((unsigned short)1, (unsigned short)1); - ulonglong2 fd1((signed short)1); - ulonglong2 fd2((signed short)1, (signed short)1); - ulonglong2 fe1((unsigned int)1); - ulonglong2 fe2((unsigned int)1, (unsigned int)1); - ulonglong2 fg1((signed int)1); - ulonglong2 fg2((signed int)1, (signed int)1); - ulonglong2 fh1((float)1); - ulonglong2 fh2((float)1, (float)1); - ulonglong2 fi1((double)1); - ulonglong2 fi2((double)1, (double)1); - ulonglong2 fj1((unsigned long)1); - ulonglong2 fj2((unsigned long)1, (unsigned long)1); - ulonglong2 fk1((signed long)1); - ulonglong2 fk2((signed long)1, (signed long)1); - ulonglong2 fl1((unsigned long long)1); - ulonglong2 fl2((unsigned long long)1, (unsigned long long)1); - ulonglong2 fm1((signed long long)1); - ulonglong2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULongLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - ulonglong3 fa1((unsigned char)1); - ulonglong3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - ulonglong3 fb1((signed char)1); - ulonglong3 fb2((signed char)1, (signed char)1, (signed char)1); - ulonglong3 fc1((unsigned short)1); - ulonglong3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - ulonglong3 fd1((signed short)1); - ulonglong3 fd2((signed short)1, (signed short)1, (signed short)1); - ulonglong3 fe1((unsigned int)1); - ulonglong3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - ulonglong3 fg1((signed int)1); - ulonglong3 fg2((signed int)1, (signed int)1, (signed int)1); - ulonglong3 fh1((float)1); - ulonglong3 fh2((float)1, (float)1, (float)1); - ulonglong3 fi1((double)1); - ulonglong3 fi2((double)1, (double)1, (double)1); - ulonglong3 fj1((unsigned long)1); - ulonglong3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - ulonglong3 fk1((signed long)1); - ulonglong3 fk2((signed long)1, (signed long)1, (signed long)1); - ulonglong3 fl1((unsigned long long)1); - ulonglong3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - ulonglong3 fm1((signed long long)1); - ulonglong3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestULongLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - ulonglong4 fa1((unsigned char)1); - ulonglong4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - ulonglong4 fb1((signed char)1); - ulonglong4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - ulonglong4 fc1((unsigned short)1); - ulonglong4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - ulonglong4 fd1((signed short)1); - ulonglong4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - ulonglong4 fe1((unsigned int)1); - ulonglong4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - ulonglong4 fg1((signed int)1); - ulonglong4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - ulonglong4 fh1((float)1); - ulonglong4 fh2((float)1, (float)1, (float)1, (float)1); - ulonglong4 fi1((double)1); - ulonglong4 fi2((double)1, (double)1, (double)1, (double)1); - ulonglong4 fj1((unsigned long)1); - ulonglong4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - ulonglong4 fk1((signed long)1); - ulonglong4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - ulonglong4 fl1((unsigned long long)1); - ulonglong4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - ulonglong4 fm1((signed long long)1); - ulonglong4 fm2((signed long long)1, (signed long long)1, (signed long long)1, - (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - - -bool TestLongLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (double)1; - cmpVal1(f1, 3); - f1 = (double)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal1(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal1(f1, 3); - - longlong1 fa((unsigned char)1); - longlong1 fb((signed char)1); - longlong1 fc((unsigned short)1); - longlong1 fd((signed short)1); - longlong1 fe((unsigned int)1); - longlong1 fg((signed int)1); - longlong1 fh((float)1); - longlong1 fi((double)1); - longlong1 fj((unsigned long)1); - longlong1 fk((signed long)1); - longlong1 fl((unsigned long long)1); - longlong1 fm((signed long long)1); - - - f1.x = 3; - f2.x = 4; - f3.x = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLongLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1 = f1 * (unsigned char)1; - cmpVal2(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed char)1; - cmpVal2(f1, 3); - f1 = (signed char)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal2(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed short)1; - cmpVal2(f1, 3); - f1 = (signed short)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal2(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed int)1; - cmpVal2(f1, 3); - f1 = (signed int)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (float)1; - cmpVal2(f1, 3); - f1 = (float)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal2(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (signed long)1; - cmpVal2(f1, 3); - f1 = (signed long)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (double)1; - cmpVal2(f1, 3); - f1 = (double)1 * f1; - cmpVal2(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal2(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal2(f1, 3); - - longlong2 fa1((unsigned char)1); - longlong2 fa2((unsigned char)1, (unsigned char)1); - longlong2 fb1((signed char)1); - longlong2 fb2((signed char)1, (signed char)1); - longlong2 fc1((unsigned short)1); - longlong2 fc2((unsigned short)1, (unsigned short)1); - longlong2 fd1((signed short)1); - longlong2 fd2((signed short)1, (signed short)1); - longlong2 fe1((unsigned int)1); - longlong2 fe2((unsigned int)1, (unsigned int)1); - longlong2 fg1((signed int)1); - longlong2 fg2((signed int)1, (signed int)1); - longlong2 fh1((float)1); - longlong2 fh2((float)1, (float)1); - longlong2 fi1((double)1); - longlong2 fi2((double)1, (double)1); - longlong2 fj1((unsigned long)1); - longlong2 fj2((unsigned long)1, (unsigned long)1); - longlong2 fk1((signed long)1); - longlong2 fk2((signed long)1, (signed long)1); - longlong2 fl1((unsigned long long)1); - longlong2 fl2((unsigned long long)1, (unsigned long long)1); - longlong2 fm1((signed long long)1); - longlong2 fm2((signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLongLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1 = f1 * (unsigned char)1; - cmpVal3(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed char)1; - cmpVal3(f1, 3); - f1 = (signed char)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal3(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed short)1; - cmpVal3(f1, 3); - f1 = (signed short)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal3(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed int)1; - cmpVal3(f1, 3); - f1 = (signed int)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (float)1; - cmpVal3(f1, 3); - f1 = (float)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal3(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (signed long)1; - cmpVal3(f1, 3); - f1 = (signed long)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (double)1; - cmpVal3(f1, 3); - f1 = (double)1 * f1; - cmpVal3(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal3(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal3(f1, 3); - - longlong3 fa1((unsigned char)1); - longlong3 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1); - longlong3 fb1((signed char)1); - longlong3 fb2((signed char)1, (signed char)1, (signed char)1); - longlong3 fc1((unsigned short)1); - longlong3 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1); - longlong3 fd1((signed short)1); - longlong3 fd2((signed short)1, (signed short)1, (signed short)1); - longlong3 fe1((unsigned int)1); - longlong3 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1); - longlong3 fg1((signed int)1); - longlong3 fg2((signed int)1, (signed int)1, (signed int)1); - longlong3 fh1((float)1); - longlong3 fh2((float)1, (float)1, (float)1); - longlong3 fi1((double)1); - longlong3 fi2((double)1, (double)1, (double)1); - longlong3 fj1((unsigned long)1); - longlong3 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1); - longlong3 fk1((signed long)1); - longlong3 fk2((signed long)1, (signed long)1, (signed long)1); - longlong3 fl1((unsigned long long)1); - longlong3 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1); - longlong3 fm1((signed long long)1); - longlong3 fm2((signed long long)1, (signed long long)1, (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; -} - -bool TestLongLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - assert(!f1 == false); - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f1 = f1 * (unsigned char)1; - cmpVal4(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed char)1; - cmpVal4(f1, 3); - f1 = (signed char)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal4(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed short)1; - cmpVal4(f1, 3); - f1 = (signed short)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal4(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed int)1; - cmpVal4(f1, 3); - f1 = (signed int)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (float)1; - cmpVal4(f1, 3); - f1 = (float)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal4(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (signed long)1; - cmpVal4(f1, 3); - f1 = (signed long)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (double)1; - cmpVal4(f1, 3); - f1 = (double)1 * f1; - cmpVal4(f1, 3); - f1 = f1 * (unsigned long long)1; - cmpVal4(f1, 3); - f1 = (unsigned long long)1 * f1; - cmpVal4(f1, 3); - - longlong4 fa1((unsigned char)1); - longlong4 fa2((unsigned char)1, (unsigned char)1, (unsigned char)1, (unsigned char)1); - longlong4 fb1((signed char)1); - longlong4 fb2((signed char)1, (signed char)1, (signed char)1, (signed char)1); - longlong4 fc1((unsigned short)1); - longlong4 fc2((unsigned short)1, (unsigned short)1, (unsigned short)1, (unsigned short)1); - longlong4 fd1((signed short)1); - longlong4 fd2((signed short)1, (signed short)1, (signed short)1, (signed short)1); - longlong4 fe1((unsigned int)1); - longlong4 fe2((unsigned int)1, (unsigned int)1, (unsigned int)1, (unsigned int)1); - longlong4 fg1((signed int)1); - longlong4 fg2((signed int)1, (signed int)1, (signed int)1, (signed int)1); - longlong4 fh1((float)1); - longlong4 fh2((float)1, (float)1, (float)1, (float)1); - longlong4 fi1((double)1); - longlong4 fi2((double)1, (double)1, (double)1, (double)1); - longlong4 fj1((unsigned long)1); - longlong4 fj2((unsigned long)1, (unsigned long)1, (unsigned long)1, (unsigned long)1); - longlong4 fk1((signed long)1); - longlong4 fk2((signed long)1, (signed long)1, (signed long)1, (signed long)1); - longlong4 fl1((unsigned long long)1); - longlong4 fl2((unsigned long long)1, (unsigned long long)1, (unsigned long long)1, - (unsigned long long)1); - longlong4 fm1((signed long long)1); - longlong4 fm2((signed long long)1, (signed long long)1, (signed long long)1, - (signed long long)1); - - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - assert((f1 == f2) == false); - assert((f1 != f2) == true); - assert((f1 < f2) == true); - assert((f2 > f1) == true); - assert((f1 >= f3) == true); - assert((f1 <= f3) == true); - - assert((f1 && f2) == true); - assert((f1 || f2) == true); - return true; +bool CheckVectorTypes() { + return TestVectorTypes< + char1, char2, char3, char4, + uchar1, uchar2, uchar3, uchar4, + short1, short2, short3, short4, + ushort1, ushort2, ushort3, ushort4, + int1, int2, int3, int4, + uint1, uint2, uint3, uint4, + long1, long2, long3, long4, + ulong1, ulong2, ulong3, ulong4, + longlong1, longlong2, longlong3, longlong4, + ulonglong1, ulonglong2, ulonglong3, ulonglong4, + float1, float2, float3, float4, + double1, double2, double3, double4>(); } int main() { - assert(sizeof(float1) == 4); - assert(sizeof(float2) == 8); - assert(sizeof(float3) == 12); - assert(sizeof(float4) == 16); - assert(TestFloat1() && TestFloat2() && TestFloat3() && TestFloat4() && TestDouble1() && - TestDouble2() && TestDouble3() && TestDouble4() && TestUChar1() && TestUChar2() && - TestUChar3() && TestUChar4() && TestChar1() && TestChar2() && TestChar3() && - TestChar4() && TestUShort1() && TestUShort2() && TestUShort3() && TestUShort4() && - TestShort1() && TestShort2() && TestShort3() && TestShort4() && TestUInt1() && - TestUInt2() && TestUInt3() && TestUInt4() && TestInt1() && TestInt2() && TestInt3() && - TestInt4() && TestULong1() && TestULong2() && TestULong3() && TestULong4() && - TestLong1() && TestLong2() && TestLong3() && TestLong4() && TestULongLong1() && - TestULongLong2() && TestULongLong3() && TestULongLong4() && TestLongLong1() && - TestLongLong2() && TestLongLong3() && TestLongLong4() == true); - passed(); - float1 f1 = make_float1(1.0f); -} + static_assert(sizeof(float1) == 4, ""); + static_assert(sizeof(float2) >= 8, ""); + static_assert(sizeof(float3) >= 12, ""); + static_assert(sizeof(float4) >= 16, ""); + + if (CheckVectorTypes()) { + float1 f1 = make_float1(1.0f); + passed(); + } + else { + failed("Failed some vector test on the host side."); + } +} \ No newline at end of file diff --git a/hipamd/tests/src/deviceLib/hipVectorTypesDevice.cpp b/hipamd/tests/src/deviceLib/hipVectorTypesDevice.cpp index 24ac3f4a02..03e8158a4e 100644 --- a/hipamd/tests/src/deviceLib/hipVectorTypesDevice.cpp +++ b/hipamd/tests/src/deviceLib/hipVectorTypesDevice.cpp @@ -26,4212 +26,177 @@ THE SOFTWARE. * HIT_END */ -#include #include + +#include "vector_test_common.h" #include "test_common.h" -#define cmpVal1(in, exp) \ - if (in.x != exp) { \ - } -#define cmpVal2(in, exp) \ - if (in.x != exp || in.y != exp) { \ - } +#include +#include +#include -#define cmpVal3(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp) { \ - } +using namespace std; -#define cmpVal4(in, exp) \ - if (in.x != exp || in.y != exp || in.z != exp || in.w != exp) { \ - } +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +constexpr +bool integer_unary_tests(const V&, const V&) { + return true; +} -__device__ bool TestUChar1() { - uchar1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_unary_tests(V& f1, V& f2) { f1 %= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; + f1 &= f2; - cmpVal1(f1, 0); + if (f1 != V{0}) return false; f1 |= f2; - cmpVal1(f1, 1); + if (f1 != V{1}) return false; f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; + if (f1 != V{0}) return false; + f1 = V{1}; f1 <<= f2; - cmpVal1(f1, 2); + if (f1 != V{2}) return false; f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - + if (f1 != V{1}) return false; f2 = ~f1; - cmpVal1(f2, 253); + return f2 == V{~1}; - f1.x = 3; - f1 = f1 * (unsigned char)1; - cmpVal1(f1, 3); - f1 = (unsigned char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed char)1; - cmpVal1(f1, 3); - f1 = (signed char)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned short)1; - cmpVal1(f1, 3); - f1 = (unsigned short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed short)1; - cmpVal1(f1, 3); - f1 = (signed short)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned int)1; - cmpVal1(f1, 3); - f1 = (unsigned int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed int)1; - cmpVal1(f1, 3); - f1 = (signed int)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (float)1; - cmpVal1(f1, 3); - f1 = (float)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (unsigned long)1; - cmpVal1(f1, 3); - f1 = (unsigned long)1 * f1; - cmpVal1(f1, 3); - f1 = f1 * (signed long)1; - cmpVal1(f1, 3); - f1 = (signed long)1 * f1; - cmpVal1(f1, 3); - - // signed char sc = 1; - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } return true; } -__device__ bool TestUChar2() { - uchar2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +constexpr +bool integer_binary_tests(const V&, const V&, const V&) { + return true; +} + +template< + typename V, + Enable_if_t().x)>{}>* = nullptr> +__device__ +bool integer_binary_tests(V& f1, V& f2, V& f3) { f3 = f1 % f2; - cmpVal2(f3, 0); + if (f3 != V{0}) return false; f1 = f3 & f2; - cmpVal2(f1, 0); + if (f1 != V{0}) return false; f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; + if (f2 != V{0}) return false; + f1 = V{1}; + f2 = V{2}; f3 = f1 << f2; - cmpVal2(f3, 4); + if (f3 != V{4}) return false; f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; + return f2 == V{2}; } -__device__ bool TestUChar3() { - uchar3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); +template +__device__ +bool TestVectorType() { + V f1{1}; + V f2{1}; + V f3 = f1 + f2; + if (f3 != V{2}) return false; f2 = f3 - f1; - cmpVal3(f2, 1); + if (f2 != V{1}) return false; f1 = f2 * f3; - cmpVal3(f1, 2); + if (f1 != V{2}) return false; f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); + if (f2 != V{1}) return false; + if (!integer_binary_tests(f1, f2, f3)) return false; - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; + f1 = V{2}; + f2 = V{1}; f1 += f2; - cmpVal3(f1, 3); + if (f1 != V{3}) return false; f1 -= f2; - cmpVal3(f1, 2); + if (f1 != V{2}) return false; f1 *= f2; - cmpVal3(f1, 2); + if (f1 != V{2}) return false; f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); + if (f1 != V{2}) return false; + if (!integer_unary_tests(f1, f2)) return false; - f1.x = 2; - f1.y = 2; - f1.z = 2; + f1 = V{2}; f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); + if (f1 != V{3}) return false; + if (f2 != V{2}) return false; f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); + if (f2 != V{3}) return false; + if (f1 != V{2}) return false; f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); + if (f1 != V{3}) return false; + if (f2 != V{3}) return false; f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUChar4() { - uchar4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar1() { - char1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar2() { - char2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar3() { - char3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestChar4() { - char4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (char)253); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort1() { - ushort1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort2() { - ushort2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort3() { - ushort3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUShort4() { - ushort4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort1() { - short1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort2() { - short2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort3() { - short3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestShort4() { - short4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed short)65533); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__device__ bool TestUInt1() { - uint1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUInt2() { - uint2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUInt3() { - uint3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestUInt4() { - uint4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (unsigned int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt1() { - int1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt2() { - int2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt3() { - int3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestInt4() { - int4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, (signed int)4294967293); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong1() { - ulong1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong2() { - ulong2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong3() { - ulong3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULong4() { - ulong4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, 18446744073709551613UL); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong1() { - long1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong2() { - long2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong3() { - long3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestLong4() { - long4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__device__ bool TestFloat1() { - float1 f1, f2, f3; - // float1 f4(1); - // cmpVal1(f4, 1.0f); - // float1 f5(2.0f); - // cmpVal1(f5, 2.0f); - f1.x = 1.0f; - f2.x = 1.0f; - f3 = f1 + f2; - cmpVal1(f3, 2.0f); - f2 = f3 - f1; - cmpVal1(f2, 1.0f); - f1 = f2 * f3; - cmpVal1(f1, 2.0f); - f2 = f1 / f3; - cmpVal1(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal1(f1, 3.0f); - f1 -= f2; - cmpVal1(f1, 2.0f); - f1 *= f2; - cmpVal1(f1, 2.0f); - f1 /= f2; - cmpVal1(f1, 2.0f); - f2 = f1++; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 2.0f); - f2 = f1--; - cmpVal1(f2, 3.0f); - cmpVal1(f1, 2.0f); - f2 = ++f1; - cmpVal1(f1, 3.0f); - cmpVal1(f2, 3.0f); - f2 = --f1; - cmpVal1(f1, 2.0f); - cmpVal1(f1, 2.0f); - - f1.x = 3.0f; - f2.x = 4.0f; - f3.x = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } + if (f1 != V{2}) return false; + if (f2 != V{2}) return false; + + f1 = V{3}; + f2 = V{4}; + f3 = V{3}; + if (f1 == f2) return false; + if (!(f1 != f2)) return false; return true; } -__device__ bool TestFloat2() { - float2 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f3 = f1 + f2; - cmpVal2(f3, 2.0f); - f2 = f3 - f1; - cmpVal2(f2, 1.0f); - f1 = f2 * f3; - cmpVal2(f1, 2.0f); - f2 = f1 / f3; - cmpVal2(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal2(f1, 3.0f); - f1 -= f2; - cmpVal2(f1, 2.0f); - f1 *= f2; - cmpVal2(f1, 2.0f); - f1 /= f2; - cmpVal2(f1, 2.0f); - - f2 = f1++; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 2.0f); - f2 = f1--; - cmpVal2(f2, 3.0f); - cmpVal2(f1, 2.0f); - f2 = ++f1; - cmpVal2(f1, 3.0f); - cmpVal2(f2, 3.0f); - f2 = --f1; - cmpVal2(f1, 2.0f); - cmpVal2(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - +template* = nullptr> +__device__ +bool TestVectorTypes() { return true; } -__device__ bool TestFloat3() { - float3 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f3 = f1 + f2; - cmpVal3(f3, 2.0f); - f2 = f3 - f1; - cmpVal3(f2, 1.0f); - f1 = f2 * f3; - cmpVal3(f1, 2.0f); - f2 = f1 / f3; - cmpVal3(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal3(f1, 3.0f); - f1 -= f2; - cmpVal3(f1, 2.0f); - f1 *= f2; - cmpVal3(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 2.0f); - f2 = f1--; - cmpVal3(f2, 3.0f); - cmpVal3(f1, 2.0f); - f2 = ++f1; - cmpVal3(f1, 3.0f); - cmpVal3(f2, 3.0f); - f2 = --f1; - cmpVal3(f1, 2.0f); - cmpVal3(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - - return true; +template +__device__ +bool TestVectorTypes() { + if (!TestVectorType()) return false; + return TestVectorTypes(); } - -__device__ bool TestFloat4() { - float4 f1, f2, f3; - f1.x = 1.0f; - f1.y = 1.0f; - f1.z = 1.0f; - f1.w = 1.0f; - f2.x = 1.0f; - f2.y = 1.0f; - f2.z = 1.0f; - f2.w = 1.0f; - f3 = f1 + f2; - cmpVal4(f3, 2.0f); - f2 = f3 - f1; - cmpVal4(f2, 1.0f); - f1 = f2 * f3; - cmpVal4(f1, 2.0f); - f2 = f1 / f3; - cmpVal4(f2, 2.0f / 2.0f); - f1 += f2; - cmpVal4(f1, 3.0f); - f1 -= f2; - cmpVal4(f1, 2.0f); - f1 *= f2; - cmpVal4(f1, 2.0f); - f1 /= f2; - f2 = f1++; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 2.0f); - f2 = f1--; - cmpVal4(f2, 3.0f); - cmpVal4(f1, 2.0f); - f2 = ++f1; - cmpVal4(f1, 3.0f); - cmpVal4(f2, 3.0f); - f2 = --f1; - cmpVal4(f1, 2.0f); - cmpVal4(f1, 2.0f); - - f1.x = 3.0f; - f1.y = 3.0f; - f1.z = 3.0f; - f1.w = 3.0f; - f2.x = 4.0f; - f2.y = 4.0f; - f2.z = 4.0f; - f2.w = 4.0f; - f3.x = 3.0f; - f3.y = 3.0f; - f3.z = 3.0f; - f3.w = 3.0f; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - return true; -} - -__device__ bool TestULongLong1() { - ulonglong1 f1, f2, f3; - f1.x = 1; - f2.x = 1; - f3 = f1 + f2; - cmpVal1(f3, 2); - f2 = f3 - f1; - cmpVal1(f2, 1); - f1 = f2 * f3; - cmpVal1(f1, 2); - f2 = f1 / f3; - cmpVal1(f2, 2 / 2); - f3 = f1 % f2; - cmpVal1(f3, 0); - f1 = f3 & f2; - cmpVal1(f1, 0); - f2 = f1 ^ f3; - cmpVal1(f2, 0); - f1.x = 1; - f2.x = 2; - f3 = f1 << f2; - cmpVal1(f3, 4); - f2 = f3 >> f1; - cmpVal1(f2, 2); - - f1.x = 2; - f2.x = 1; - f1 += f2; - cmpVal1(f1, 3); - f1 -= f2; - cmpVal1(f1, 2); - f1 *= f2; - cmpVal1(f1, 2); - f1 /= f2; - cmpVal1(f1, 2); - f1 %= f2; - cmpVal1(f1, 0); - f1 &= f2; - cmpVal1(f1, 0); - f1 |= f2; - cmpVal1(f1, 1); - f1 ^= f2; - cmpVal1(f1, 0); - f1.x = 1; - f1 <<= f2; - cmpVal1(f1, 2); - f1 >>= f2; - cmpVal1(f1, 1); - - f1.x = 2; - f2 = f1++; - cmpVal1(f1, 3); - cmpVal1(f2, 2); - f2 = f1--; - cmpVal1(f2, 3); - cmpVal1(f1, 2); - f2 = ++f1; - cmpVal1(f1, 3); - cmpVal1(f2, 3); - f2 = --f1; - cmpVal1(f1, 2); - cmpVal1(f2, 2); - - f2 = ~f1; - cmpVal1(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f2.x = 4; - f3.x = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__device__ bool TestULongLong2() { - ulonglong2 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f2.x = 1; - f2.y = 1; - f3 = f1 + f2; - cmpVal2(f3, 2); - f2 = f3 - f1; - cmpVal2(f2, 1); - f1 = f2 * f3; - cmpVal2(f1, 2); - f2 = f1 / f3; - cmpVal2(f2, 2 / 2); - f3 = f1 % f2; - cmpVal2(f3, 0); - f1 = f3 & f2; - cmpVal2(f1, 0); - f2 = f1 ^ f3; - cmpVal2(f2, 0); - f1.x = 1; - f1.y = 1; - f2.x = 2; - f2.y = 2; - f3 = f1 << f2; - cmpVal2(f3, 4); - f2 = f3 >> f1; - cmpVal2(f2, 2); - - f1.x = 2; - f1.y = 2; - f2.x = 1; - f2.y = 1; - f1 += f2; - cmpVal2(f1, 3); - f1 -= f2; - cmpVal2(f1, 2); - f1 *= f2; - cmpVal2(f1, 2); - f1 /= f2; - cmpVal2(f1, 2); - f1 %= f2; - cmpVal2(f1, 0); - f1 &= f2; - cmpVal2(f1, 0); - f1 |= f2; - cmpVal2(f1, 1); - f1 ^= f2; - cmpVal2(f1, 0); - f1.x = 1; - f1.y = 1; - f1 <<= f2; - cmpVal2(f1, 2); - f1 >>= f2; - cmpVal2(f1, 1); - - f1.x = 2; - f1.y = 2; - f2 = f1++; - cmpVal2(f1, 3); - cmpVal2(f2, 2); - f2 = f1--; - cmpVal2(f2, 3); - cmpVal2(f1, 2); - f2 = ++f1; - cmpVal2(f1, 3); - cmpVal2(f2, 3); - f2 = --f1; - cmpVal2(f1, 2); - cmpVal2(f2, 2); - - f2 = ~f1; - cmpVal2(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f2.x = 4; - f2.y = 4; - f3.x = 3; - f3.y = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULongLong3() { - ulonglong3 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f3 = f1 + f2; - cmpVal3(f3, 2); - f2 = f3 - f1; - cmpVal3(f2, 1); - f1 = f2 * f3; - cmpVal3(f1, 2); - f2 = f1 / f3; - cmpVal3(f2, 2 / 2); - f3 = f1 % f2; - cmpVal3(f3, 0); - f1 = f3 & f2; - cmpVal3(f1, 0); - f2 = f1 ^ f3; - cmpVal3(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f3 = f1 << f2; - cmpVal3(f3, 4); - f2 = f3 >> f1; - cmpVal3(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f1 += f2; - cmpVal3(f1, 3); - f1 -= f2; - cmpVal3(f1, 2); - f1 *= f2; - cmpVal3(f1, 2); - f1 /= f2; - cmpVal3(f1, 2); - f1 %= f2; - cmpVal3(f1, 0); - f1 &= f2; - cmpVal3(f1, 0); - f1 |= f2; - cmpVal3(f1, 1); - f1 ^= f2; - cmpVal3(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1 <<= f2; - cmpVal3(f1, 2); - f1 >>= f2; - cmpVal3(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f2 = f1++; - cmpVal3(f1, 3); - cmpVal3(f2, 2); - f2 = f1--; - cmpVal3(f2, 3); - cmpVal3(f1, 2); - f2 = ++f1; - cmpVal3(f1, 3); - cmpVal3(f2, 3); - f2 = --f1; - cmpVal3(f1, 2); - cmpVal3(f2, 2); - - f2 = ~f1; - cmpVal3(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - -__device__ bool TestULongLong4() { - ulonglong4 f1, f2, f3; - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f3 = f1 + f2; - cmpVal4(f3, 2); - f2 = f3 - f1; - cmpVal4(f2, 1); - f1 = f2 * f3; - cmpVal4(f1, 2); - f2 = f1 / f3; - cmpVal4(f2, 2 / 2); - f3 = f1 % f2; - cmpVal4(f3, 0); - f1 = f3 & f2; - cmpVal4(f1, 0); - f2 = f1 ^ f3; - cmpVal4(f2, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f2.x = 2; - f2.y = 2; - f2.z = 2; - f2.w = 2; - f3 = f1 << f2; - cmpVal4(f3, 4); - f2 = f3 >> f1; - cmpVal4(f2, 2); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2.x = 1; - f2.y = 1; - f2.z = 1; - f2.w = 1; - f1 += f2; - cmpVal4(f1, 3); - f1 -= f2; - cmpVal4(f1, 2); - f1 *= f2; - cmpVal4(f1, 2); - f1 /= f2; - cmpVal4(f1, 2); - f1 %= f2; - cmpVal4(f1, 0); - f1 &= f2; - cmpVal4(f1, 0); - f1 |= f2; - cmpVal4(f1, 1); - f1 ^= f2; - cmpVal4(f1, 0); - f1.x = 1; - f1.y = 1; - f1.z = 1; - f1.w = 1; - f1 <<= f2; - cmpVal4(f1, 2); - f1 >>= f2; - cmpVal4(f1, 1); - - f1.x = 2; - f1.y = 2; - f1.z = 2; - f1.w = 2; - f2 = f1++; - cmpVal4(f1, 3); - cmpVal4(f2, 2); - f2 = f1--; - cmpVal4(f2, 3); - cmpVal4(f1, 2); - f2 = ++f1; - cmpVal4(f1, 3); - cmpVal4(f2, 3); - f2 = --f1; - cmpVal4(f1, 2); - cmpVal4(f2, 2); - - f2 = ~f1; - cmpVal4(f2, -3); - if (!f1 == false) { - } - - f1.x = 3; - f1.y = 3; - f1.z = 3; - f1.w = 3; - f2.x = 4; - f2.y = 4; - f2.z = 4; - f2.w = 4; - f3.x = 3; - f3.y = 3; - f3.z = 3; - f3.w = 3; - if ((f1 == f2) == false) { - } - if ((f1 != f2) == true) { - } - if ((f1 < f2) == true) { - } - if ((f2 > f1) == true) { - } - if ((f1 >= f3) == true) { - } - if ((f1 <= f3) == true) { - } - - if ((f1 && f2) == true) { - } - if ((f1 || f2) == true) { - } - return true; -} - - -__global__ void CheckVectorTypes(hipLaunchParm lp, bool* ptr) { - if (TestFloat1() && TestFloat2() && TestFloat3() && TestFloat4() && TestUChar1() && - TestUChar2() && TestUChar3() && TestUChar4() && TestChar1() && TestChar2() && TestChar3() && - TestChar4() && TestUShort1() && TestUShort2() && TestUShort3() && TestUShort4() && - TestShort1() && TestShort2() && TestShort3() && TestShort4() && TestUInt1() && - TestUInt2() && TestUInt3() && TestUInt4() && TestInt1() && TestInt2() && TestInt3() && - TestInt4() && TestULong1() && TestULong2() && TestULong3() && TestULong4() && TestLong1() && - TestLong2() && TestLong3() && TestLong4() && TestULongLong1() && TestULongLong2() && - TestULongLong3() && TestULongLong4() == true) { - ptr[0] = true; - } +__global__ +void CheckVectorTypes(bool* ptr) { + ptr[0] = TestVectorTypes< + char1, char2, char3, char4, + uchar1, uchar2, uchar3, uchar4, + short1, short2, short3, short4, + ushort1, ushort2, ushort3, ushort4, + int1, int2, int3, int4, + uint1, uint2, uint3, uint4, + long1, long2, long3, long4, + ulong1, ulong2, ulong3, ulong4, + longlong1, longlong2, longlong3, longlong4, + ulonglong1, ulonglong2, ulonglong3, ulonglong4, + float1, float2, float3, float4, + double1, double2, double3, double4>(); } int main() { - assert(sizeof(float1) == 4); - assert(sizeof(float2) == 8); - assert(sizeof(float3) == 12); - assert(sizeof(float4) == 16); + static_assert(sizeof(float1) == 4, ""); + static_assert(sizeof(float2) >= 8, ""); + static_assert(sizeof(float3) >= 12, ""); + static_assert(sizeof(float4) >= 16, ""); bool* ptr = nullptr; if (hipMalloc(&ptr, sizeof(bool)) != HIP_SUCCESS) return EXIT_FAILURE; - std::unique_ptr correct{ptr, hipFree}; - hipLaunchKernel(CheckVectorTypes, dim3(1, 1, 1), dim3(1, 1, 1), 0, 0, correct.get()); - bool passed = false; + unique_ptr correct{ptr, hipFree}; + hipLaunchKernelGGL( + CheckVectorTypes, dim3(1, 1, 1), dim3(1, 1, 1), 0, 0, correct.get()); + bool passed = true; if (hipMemcpyDtoH(&passed, correct.get(), sizeof(bool)) != HIP_SUCCESS) { return EXIT_FAILURE; } if (passed == true) { - std::cout << "PASSED" << std::endl; - return 0; - } else - return EXIT_FAILURE; -} + passed(); + } + else { + failed("Failed some vector test."); + } +} \ No newline at end of file diff --git a/hipamd/tests/src/deviceLib/hip_mbcnt.cpp b/hipamd/tests/src/deviceLib/hip_mbcnt.cpp index 0dd7169f51..9fdf36a1d3 100644 --- a/hipamd/tests/src/deviceLib/hip_mbcnt.cpp +++ b/hipamd/tests/src/deviceLib/hip_mbcnt.cpp @@ -88,7 +88,7 @@ int main() { for (unsigned int i = 0; i < num_threads; i++) { unsigned int this_lane_id = i % wave_size; unsigned int this_mbcnt_lo = this_lane_id >= 32 ? 32 : this_lane_id; - unsigned int this_mbcnt_hi = this_lane_id < 32 ? 0 : (this_lane_id - 22); + unsigned int this_mbcnt_hi = this_lane_id < 32 ? 0 : (this_lane_id - 32); if (host_mbcnt_lo[i] != this_mbcnt_lo) mbcnt_lo_errors++; diff --git a/hipamd/tests/src/deviceLib/hip_test_ldg.cpp b/hipamd/tests/src/deviceLib/hip_test_ldg.cpp index 4dea81d9b9..7274baa92c 100644 --- a/hipamd/tests/src/deviceLib/hip_test_ldg.cpp +++ b/hipamd/tests/src/deviceLib/hip_test_ldg.cpp @@ -35,7 +35,7 @@ THE SOFTWARE. #include "hip/hip_vector_types.h" #include "test_common.h" -#if (__hcc_workweek__ >= 16164) || defined(__HIP_PLATFORM_NVCC__) +#if (__hcc_workweek__ >= 16164) || defined(__HIP_PLATFORM_NVCC__) || defined(__HIP_CLANG_ONLY__) #define HIP_ASSERT(x) (assert((x) == hipSuccess)) diff --git a/hipamd/tests/src/deviceLib/vector_test_common.h b/hipamd/tests/src/deviceLib/vector_test_common.h new file mode 100644 index 0000000000..fac5ab84a1 --- /dev/null +++ b/hipamd/tests/src/deviceLib/vector_test_common.h @@ -0,0 +1,69 @@ +/* +Copyright (c) 2015-2017 Advanced Micro Devices, Inc. All rights reserved. + +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. + +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. 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. +*/ +#pragma once + +#include + +template +using Enable_if_t = typename std::enable_if::type; + +__host__ __device__ +std::false_type is_vec4(...); +__host__ __device__ +std::false_type is_vec3(...); +__host__ __device__ +std::false_type is_vec2(...); +__host__ __device__ +std::false_type is_vec1(...); + +template +__host__ __device__ +auto is_vec4(const T&) -> decltype(std::declval().xyzw, std::true_type{}); +template< + typename T, Enable_if_t())){}>* = nullptr> +__host__ __device__ +auto is_vec3(const T&) -> decltype(std::declval().xyz, std::true_type{}); +template< + typename T, + Enable_if_t< + !decltype(is_vec4(std::declval())){} && + !decltype(is_vec3(std::declval())){}>* = nullptr> +__host__ __device__ +auto is_vec2(const T&) -> decltype(std::declval().xy, std::true_type{}); +template< + typename T, + Enable_if_t< + !decltype(is_vec4(std::declval())){} && + !decltype(is_vec3(std::declval())){} && + !decltype(is_vec2(std::declval())){}>* = nullptr> +__host__ __device__ +auto is_vec1(const T&) -> decltype(std::declval().x, std::true_type{}); + +template +__host__ __device__ +constexpr +bool is_vec() { + return (dimension == 1) ? decltype(is_vec1(std::declval())){} : + ((dimension == 2) ? decltype(is_vec2(std::declval())){} : + ((dimension == 3) ? decltype(is_vec3(std::declval())){} : + decltype(is_vec4(std::declval())){})); +} \ No newline at end of file