Werror fixes

A bunch of fixes to get `-Werror` builds to pass,
both on Linux and on Windows (`/WX`)

* Disable verbose Windows warnings
  * `_CRT_SECURE_NO_WARNINGS` because of `std::getenv`
  * C4267 because of conversions from `size_t` to other integers
* Define `WIN32_LEAN_AND_MEAN` and `NOMINMAX` on Windows
  * Gets rid of some errors and speeds up the build
* Convert integer CUDA objects to std::uintptr_t
  before reinterpreting them to a pointer
* Fixed "unused function" warning for `GetHipFormatPixelSize`
  * There was a lot of duplication, now a single function
    called `imageElementByteSize`
* Mark some variables as potentially unused (only used in asserts)
* Other minor fixes

Author: ProGTX

CMakeLists.txt

@@ -116,9 +116,6 @@ if(UR_ENABLE_TRACING)
     )
     if (MSVC)
         set(TARGET_XPTI $<IF:$<CONFIG:Release>,xpti,xptid>)
-
-        # disable warning C4267: The compiler detected a conversion from size_t to a smaller type.
-        target_compile_options(xptifw PRIVATE /wd4267)
     else()
         set(TARGET_XPTI xpti)
     endif()

cmake/helpers.cmake

@@ -84,10 +84,16 @@ function(add_ur_target_compile_options name)
             /W3
             /MD$<$<CONFIG:Debug>:d>
             /GS
+            /DWIN32_LEAN_AND_MEAN
+            /DNOMINMAX
         )
 
         if(UR_DEVELOPER_MODE)
-            target_compile_options(${name} PRIVATE /WX /GS)
+            # _CRT_SECURE_NO_WARNINGS used mainly because of getenv
+            # C4267: The compiler detected a conversion from size_t to a smaller type.
+            target_compile_options(${name} PRIVATE
+                /WX /GS /D_CRT_SECURE_NO_WARNINGS /wd4267
+            )
         endif()
     endif()
 endfunction()

source/adapters/cuda/device.cpp

@@ -1101,7 +1101,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(ur_platform_handle_t hPlatform,
 
 UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetNativeHandle(
     ur_device_handle_t hDevice, ur_native_handle_t *phNativeHandle) {
-  *phNativeHandle = reinterpret_cast<ur_native_handle_t>(hDevice->get());
+  *phNativeHandle = reinterpret_cast<ur_native_handle_t>(
+      static_cast<std::uintptr_t>(hDevice->get()));
   return UR_RESULT_SUCCESS;
 }
 

source/adapters/cuda/image.cpp

@@ -146,7 +146,7 @@ urToCudaImageChannelFormat(ur_image_channel_type_t image_channel_type,
           std::make_pair(image_channel_type, num_channels));
       cuda_format = cuda_format_and_size.first;
       pixel_size_bytes = cuda_format_and_size.second;
-    } catch (std::out_of_range &e) {
+    } catch (const std::out_of_range &) {
       return UR_RESULT_ERROR_IMAGE_FORMAT_NOT_SUPPORTED;
     }
   }
@@ -276,7 +276,7 @@ ur_result_t urTextureCreate(ur_sampler_handle_t hSampler,
     ImageTexDesc.mipmapFilterMode = MipFilterMode;
     ImageTexDesc.maxMipmapLevelClamp = hSampler->MaxMipmapLevelClamp;
     ImageTexDesc.minMipmapLevelClamp = hSampler->MinMipmapLevelClamp;
-    ImageTexDesc.maxAnisotropy = hSampler->MaxAnisotropy;
+    ImageTexDesc.maxAnisotropy = static_cast<unsigned>(hSampler->MaxAnisotropy);
 
     // The address modes can interfere with other dimensionsenqueueEventsWait
     // e.g. 1D texture sampling can be interfered with when setting other

source/adapters/cuda/program.cpp

@@ -141,7 +141,8 @@ ur_result_t ur_program_handle_t_::buildProgram(const char *BuildOptions) {
         getMaxRegistersJitOptionValue(this->BuildOptions, MaxRegs);
     if (Valid) {
       Options.push_back(CU_JIT_MAX_REGISTERS);
-      OptionVals.push_back(reinterpret_cast<void *>(MaxRegs));
+      OptionVals.push_back(
+          reinterpret_cast<void *>(static_cast<std::uintptr_t>(MaxRegs)));
     }
   }
 

source/adapters/cuda/sampler.cpp

@@ -18,7 +18,7 @@ urSamplerCreate(ur_context_handle_t hContext, const ur_sampler_desc_t *pDesc,
       new ur_sampler_handle_t_(hContext)};
 
   if (pDesc->stype == UR_STRUCTURE_TYPE_SAMPLER_DESC) {
-    Sampler->Props |= pDesc->normalizedCoords;
+    Sampler->Props |= static_cast<uint32_t>(pDesc->normalizedCoords);
     Sampler->Props |= pDesc->filterMode << 1;
     Sampler->Props |= pDesc->addressingMode << 2;
   } else {

source/adapters/hip/enqueue.cpp

@@ -15,26 +15,9 @@
 #include "memory.hpp"
 #include "queue.hpp"
 
-namespace {
+extern size_t imageElementByteSize(hipArray_Format ArrayFormat);
 
-static size_t imageElementByteSize(hipArray_Format ArrayFormat) {
-  switch (ArrayFormat) {
-  case HIP_AD_FORMAT_UNSIGNED_INT8:
-  case HIP_AD_FORMAT_SIGNED_INT8:
-    return 1;
-  case HIP_AD_FORMAT_UNSIGNED_INT16:
-  case HIP_AD_FORMAT_SIGNED_INT16:
-  case HIP_AD_FORMAT_HALF:
-    return 2;
-  case HIP_AD_FORMAT_UNSIGNED_INT32:
-  case HIP_AD_FORMAT_SIGNED_INT32:
-  case HIP_AD_FORMAT_FLOAT:
-    return 4;
-  default:
-    detail::ur::die("Invalid image format.");
-  }
-  return 0;
-}
+namespace {
 
 ur_result_t enqueueEventsWait(ur_queue_handle_t, hipStream_t Stream,
                               uint32_t NumEventsInWaitList,

source/adapters/hip/memory.cpp

@@ -13,10 +13,8 @@
 #include <cassert>
 #include <ur_util.hpp>
 
-namespace {
-
-size_t GetHipFormatPixelSize(hipArray_Format Format) {
-  switch (Format) {
+size_t imageElementByteSize(hipArray_Format ArrayFormat) {
+  switch (ArrayFormat) {
   case HIP_AD_FORMAT_UNSIGNED_INT8:
   case HIP_AD_FORMAT_SIGNED_INT8:
     return 1;
@@ -31,10 +29,9 @@ size_t GetHipFormatPixelSize(hipArray_Format Format) {
   default:
     detail::ur::die("Invalid HIP format specifier");
   }
+  return 0;
 }
 
-} // namespace
-
 /// Decreases the reference count of the Mem object.
 /// If this is zero, calls the relevant HIP Free function
 /// \return UR_RESULT_SUCCESS unless deallocation error
@@ -245,7 +242,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemGetInfo(ur_mem_handle_t hMemory,
           UR_CHECK_ERROR(
               hipArray3DGetDescriptor(&ArrayDescriptor, Mem.getArray(Device)));
           const auto PixelSizeBytes =
-              GetHipFormatPixelSize(ArrayDescriptor.Format) *
+              imageElementByteSize(ArrayDescriptor.Format) *
               ArrayDescriptor.NumChannels;
           const auto ImageSizeBytes =
               PixelSizeBytes *
@@ -405,25 +402,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageGetInfo(ur_mem_handle_t hMemory,
       }
     };
 
-    const auto hipFormatToElementSize =
-        [](hipArray_Format HipFormat) -> size_t {
-      switch (HipFormat) {
-      case HIP_AD_FORMAT_UNSIGNED_INT8:
-      case HIP_AD_FORMAT_SIGNED_INT8:
-        return 1;
-      case HIP_AD_FORMAT_UNSIGNED_INT16:
-      case HIP_AD_FORMAT_SIGNED_INT16:
-      case HIP_AD_FORMAT_HALF:
-        return 2;
-      case HIP_AD_FORMAT_UNSIGNED_INT32:
-      case HIP_AD_FORMAT_SIGNED_INT32:
-      case HIP_AD_FORMAT_FLOAT:
-        return 4;
-      default:
-        detail::ur::die("Invalid Hip format specified.");
-      }
-    };
-
     switch (propName) {
     case UR_IMAGE_INFO_FORMAT:
       return ReturnValue(ur_image_format_t{UR_IMAGE_CHANNEL_ORDER_RGBA,
@@ -435,7 +413,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageGetInfo(ur_mem_handle_t hMemory,
     case UR_IMAGE_INFO_DEPTH:
       return ReturnValue(ArrayInfo.Depth);
     case UR_IMAGE_INFO_ELEMENT_SIZE:
-      return ReturnValue(hipFormatToElementSize(ArrayInfo.Format));
+      return ReturnValue(imageElementByteSize(ArrayInfo.Format));
     case UR_IMAGE_INFO_ROW_PITCH:
     case UR_IMAGE_INFO_SLICE_PITCH:
       return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;

source/adapters/level_zero/CMakeLists.txt

@@ -124,7 +124,7 @@ add_ur_adapter(${TARGET_NAME}
 
 # TODO: fix level_zero adapter conversion warnings
 target_compile_options(${TARGET_NAME} PRIVATE
-    $<$<CXX_COMPILER_ID:MSVC>:/wd4267 /wd4805 /wd4244 /D_CRT_SECURE_NO_WARNINGS>
+    $<$<CXX_COMPILER_ID:MSVC>:/wd4805 /wd4244>
 )
 
 set_target_properties(${TARGET_NAME} PROPERTIES

source/adapters/native_cpu/context.cpp

@@ -17,10 +17,10 @@
 #include "common.hpp"
 #include "context.hpp"
 
-UR_APIEXPORT ur_result_t UR_APICALL
-urContextCreate(uint32_t DeviceCount, const ur_device_handle_t *phDevices,
-                const ur_context_properties_t *pProperties,
-                ur_context_handle_t *phContext) {
+UR_APIEXPORT ur_result_t UR_APICALL urContextCreate(
+    [[maybe_unused]] uint32_t DeviceCount, const ur_device_handle_t *phDevices,
+    const ur_context_properties_t *pProperties,
+    ur_context_handle_t *phContext) {
   std::ignore = pProperties;
   assert(DeviceCount == 1);