[SYCL] Fix various runtime compilation warnings (#2980)

* [SYCL] Fix various runtime compilation warnings

- implicit conversion of string to bool
- unused variables
- default label in switch which covers all enumeration items
- unannotated fall-through in switch

Co-authored-by: Vyacheslav N Klochkov <[email protected]>

Author: sergey-semenov

sycl/include/CL/sycl/detail/defines_elementary.hpp

@@ -22,11 +22,13 @@
 #define __has_builtin(x) 0
 #endif // __has_builtin
 
+#ifndef __SYCL_ALWAYS_INLINE
 #if __has_attribute(always_inline)
 #define __SYCL_ALWAYS_INLINE __attribute__((always_inline))
 #else
 #define __SYCL_ALWAYS_INLINE
 #endif
+#endif // __SYCL_ALWAYS_INLINE
 
 #ifndef SYCL_EXTERNAL
 #define SYCL_EXTERNAL
@@ -36,15 +38,42 @@
 #define __SYCL_ID_QUERIES_FIT_IN_INT__ 0
 #endif
 
+#ifndef __SYCL_DEPRECATED
 #ifdef _WIN32
 #define __SYCL_DEPRECATED(message) __declspec(deprecated(message))
 #else
 #define __SYCL_DEPRECATED(message) __attribute__((deprecated(message)))
 #endif
+#endif // __SYCL_DEPRECATED
 
+#ifndef __SYCL_INLINE_CONSTEXPR
 // inline constexpr is a C++17 feature
 #if __cplusplus >= 201703L
 #define __SYCL_INLINE_CONSTEXPR inline constexpr
 #else
 #define __SYCL_INLINE_CONSTEXPR static constexpr
 #endif
+#endif // __SYCL_INLINE_CONSTEXPR
+
+#ifndef __SYCL_HAS_CPP_ATTRIBUTE
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+#define __SYCL_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#define __SYCL_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+#endif
+
+#ifndef __SYCL_FALLTHROUGH
+#if defined(__cplusplus) && __cplusplus > 201402L &&                           \
+    __SYCL_HAS_CPP_ATTRIBUTE(fallthrough)
+#define __SYCL_FALLTHROUGH [[fallthrough]]
+#elif __SYCL_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
+#define __SYCL_FALLTHROUGH [[gnu::fallthrough]]
+#elif __has_attribute(fallthrough)
+#define __SYCL_FALLTHROUGH __attribute__((fallthrough))
+#elif __SYCL_HAS_CPP_ATTRIBUTE(clang::fallthrough)
+#define __SYCL_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define __SYCL_FALLTHROUGH
+#endif
+#endif // __SYCL_FALLTHROUGH

sycl/include/CL/sycl/types.hpp

@@ -296,10 +296,9 @@ detail::enable_if_t<is_float_to_int<T, R>::value, R> convertImpl(T Value) {
     // Round toward negative infinity.
   case rounding_mode::rtn:
     return std::floor(Value);
-  default:
-    assert(!"Unsupported rounding mode!");
-    return static_cast<R>(Value);
   };
+  assert(false && "Unsupported rounding mode!");
+  return static_cast<R>(Value);
 }
 #else
 

sycl/source/detail/builtins_math.cpp

@@ -609,12 +609,15 @@ MAKE_1V_2P(modf, s::cl_half, s::cl_half, s::cl_half)
 
 // nan
 __SYCL_EXPORT s::cl_float nan(s::cl_uint nancode) __NOEXC {
+  (void)nancode;
   return d::quiet_NaN<s::cl_float>();
 }
 __SYCL_EXPORT s::cl_double nan(s::cl_ulong nancode) __NOEXC {
+  (void)nancode;
   return d::quiet_NaN<s::cl_double>();
 }
 __SYCL_EXPORT s::cl_half nan(s::cl_ushort nancode) __NOEXC {
+  (void)nancode;
   return s::cl_half(d::quiet_NaN<s::cl_float>());
 }
 MAKE_1V(nan, s::cl_float, s::cl_uint)

sycl/source/detail/image_impl.cpp

@@ -62,7 +62,7 @@ uint8_t getImageNumberChannels(image_channel_order Order) {
   case image_channel_order::abgr:
     return 4;
   }
-  assert(!"Unhandled image channel order");
+  assert(false && "Unhandled image channel order");
   return 0;
 }
 
@@ -95,8 +95,6 @@ uint8_t getImageElementSize(uint8_t NumChannels, image_channel_type Type) {
   case image_channel_type::unorm_int_101010:
     Retval = 4;
     break;
-  default:
-    assert(!"Unhandled image channel type");
   }
   // OpenCL states that "The number of bits per element determined by the
   // image_channel_type and image_channel_order must be a power of two"
@@ -135,11 +133,9 @@ RT::PiMemImageChannelOrder convertChannelOrder(image_channel_order Order) {
     return PI_IMAGE_CHANNEL_ORDER_LUMINANCE;
   case image_channel_order::abgr:
     return PI_IMAGE_CHANNEL_ORDER_ABGR;
-  default: {
-    assert(!"Unhandled image_channel_order");
-    return static_cast<RT::PiMemImageChannelOrder>(0);
-  }
   }
+  assert(false && "Unhandled image_channel_order");
+  return static_cast<RT::PiMemImageChannelOrder>(0);
 }
 
 image_channel_order convertChannelOrder(RT::PiMemImageChannelOrder Order) {
@@ -172,11 +168,9 @@ image_channel_order convertChannelOrder(RT::PiMemImageChannelOrder Order) {
     return image_channel_order::luminance;
   case PI_IMAGE_CHANNEL_ORDER_ABGR:
     return image_channel_order::abgr;
-  default: {
-    assert(!"Unhandled image_channel_order");
-    return static_cast<image_channel_order>(0);
-  }
   }
+  assert(false && "Unhandled image_channel_order");
+  return static_cast<image_channel_order>(0);
 }
 
 RT::PiMemImageChannelType convertChannelType(image_channel_type Type) {
@@ -211,11 +205,9 @@ RT::PiMemImageChannelType convertChannelType(image_channel_type Type) {
     return PI_IMAGE_CHANNEL_TYPE_HALF_FLOAT;
   case image_channel_type::fp32:
     return PI_IMAGE_CHANNEL_TYPE_FLOAT;
-  default: {
-    assert(!"Unhandled image_channel_order");
-    return static_cast<RT::PiMemImageChannelType>(0);
-  }
   }
+  assert(false && "Unhandled image_channel_order");
+  return static_cast<RT::PiMemImageChannelType>(0);
 }
 
 image_channel_type convertChannelType(RT::PiMemImageChannelType Type) {
@@ -250,11 +242,9 @@ image_channel_type convertChannelType(RT::PiMemImageChannelType Type) {
     return image_channel_type::fp16;
   case PI_IMAGE_CHANNEL_TYPE_FLOAT:
     return image_channel_type::fp32;
-  default: {
-    assert(!"Unhandled image_channel_order");
-    return static_cast<image_channel_type>(0);
-  }
   }
+  assert(false && "Unhandled image_channel_order");
+  return static_cast<image_channel_type>(0);
 }
 
 template <typename T>
@@ -294,10 +284,10 @@ image_impl<Dimensions>::image_impl(
   switch (Dimensions) {
   case 3:
     getImageInfo(Context, PI_IMAGE_INFO_DEPTH, MRange[2], Mem);
-    // fall through
+    __SYCL_FALLTHROUGH;
   case 2:
     getImageInfo(Context, PI_IMAGE_INFO_HEIGHT, MRange[1], Mem);
-    // fall through
+    __SYCL_FALLTHROUGH;
   case 1:
     getImageInfo(Context, PI_IMAGE_INFO_WIDTH, MRange[0], Mem);
   }
@@ -407,6 +397,7 @@ bool image_impl<Dimensions>::checkImageDesc(const RT::PiMemImageDesc &Desc,
 template <int Dimensions>
 bool image_impl<Dimensions>::checkImageFormat(
     const RT::PiMemImageFormat &Format, ContextImplPtr Context) {
+  (void)Context;
   if (checkAny(Format.image_channel_order, PI_IMAGE_CHANNEL_ORDER_INTENSITY,
                PI_IMAGE_CHANNEL_ORDER_LUMINANCE) &&
       !checkAny(

sycl/source/detail/memory_manager.cpp

@@ -47,6 +47,8 @@ void MemoryManager::release(ContextImplPtr TargetContext, SYCLMemObjI *MemObj,
 
 void MemoryManager::releaseImageBuffer(ContextImplPtr TargetContext,
                                        void *ImageBuf) {
+  (void)TargetContext;
+  (void)ImageBuf;
   // TODO remove when ABI breaking changes are allowed.
   throw runtime_error("Deprecated release operation", PI_INVALID_OPERATION);
 }
@@ -83,6 +85,9 @@ void *MemoryManager::allocate(ContextImplPtr TargetContext, SYCLMemObjI *MemObj,
 
 void *MemoryManager::wrapIntoImageBuffer(ContextImplPtr TargetContext,
                                          void *MemBuf, SYCLMemObjI *MemObj) {
+  (void)TargetContext;
+  (void)MemBuf;
+  (void)MemObj;
   // TODO remove when ABI breaking changes are allowed.
   throw runtime_error("Deprecated allocation operation", PI_INVALID_OPERATION);
 }
@@ -279,6 +284,7 @@ void copyH2D(SYCLMemObjI *SYCLMemObj, char *SrcMem, QueueImplPtr,
              sycl::range<3> DstAccessRange, sycl::id<3> DstOffset,
              unsigned int DstElemSize, std::vector<RT::PiEvent> DepEvents,
              RT::PiEvent &OutEvent) {
+  (void)SrcAccessRange;
   assert(SYCLMemObj && "The SYCLMemObj is nullptr");
 
   const RT::PiQueue Queue = TgtQueue->getHandleRef();
@@ -350,6 +356,7 @@ void copyD2H(SYCLMemObjI *SYCLMemObj, RT::PiMem SrcMem, QueueImplPtr SrcQueue,
              sycl::range<3> DstAccessRange, sycl::id<3> DstOffset,
              unsigned int DstElemSize, std::vector<RT::PiEvent> DepEvents,
              RT::PiEvent &OutEvent) {
+  (void)DstAccessRange;
   assert(SYCLMemObj && "The SYCLMemObj is nullptr");
 
   const RT::PiQueue Queue = SrcQueue->getHandleRef();

sycl/source/detail/pi.cpp

@@ -142,10 +142,9 @@ std::string platformInfoToString(pi_platform_info info) {
     return "PI_PLATFORM_INFO_VENDOR";
   case PI_PLATFORM_INFO_EXTENSIONS:
     return "PI_PLATFORM_INFO_EXTENSIONS";
-  default:
-    die("Unknown pi_platform_info value passed to "
-        "cl::sycl::detail::pi::platformInfoToString");
   }
+  die("Unknown pi_platform_info value passed to "
+      "cl::sycl::detail::pi::platformInfoToString");
 }
 
 std::string memFlagToString(pi_mem_flags Flag) {

sycl/source/detail/program_impl.cpp

@@ -381,7 +381,7 @@ void program_impl::build(const string_class &Options) {
   check_device_feature_support<info::device::is_compiler_available>(MDevices);
   vector_class<RT::PiDevice> Devices(get_pi_devices());
   const detail::plugin &Plugin = getPlugin();
-  ProgramManager::getInstance().flushSpecConstants(*this, get_pi_devices()[0]);
+  ProgramManager::getInstance().flushSpecConstants(*this);
   RT::PiResult Err = Plugin.call_nocheck<PiApiKind::piProgramBuild>(
       MProgram, Devices.size(), Devices.data(), Options.c_str(), nullptr,
       nullptr);

sycl/source/detail/program_manager/program_manager.cpp

@@ -376,8 +376,7 @@ RT::PiProgram ProgramManager::getBuiltPIProgram(OSModuleHandle M,
     const detail::plugin &Plugin = ContextImpl->getPlugin();
     RT::PiProgram NativePrg = createPIProgram(Img, Context, Device);
     if (Prg)
-      flushSpecConstants(*Prg, getSyclObjImpl(Device)->getHandleRef(),
-                         NativePrg, &Img);
+      flushSpecConstants(*Prg, NativePrg, &Img);
     ProgramPtr ProgramManaged(
         NativePrg, Plugin.getPiPlugin().PiFunctionTable.piProgramRelease);
 
@@ -1011,7 +1010,6 @@ void ProgramManager::dumpImage(const RTDeviceBinaryImage &Img,
 }
 
 void ProgramManager::flushSpecConstants(const program_impl &Prg,
-                                        RT::PiDevice Device,
                                         RT::PiProgram NativePrg,
                                         const RTDeviceBinaryImage *Img) {
   if (DbgProgMgr > 2) {
@@ -1122,5 +1120,6 @@ extern "C" void __sycl_register_lib(pi_device_binaries desc) {
 
 // Executed as a part of current module's (.exe, .dll) static initialization
 extern "C" void __sycl_unregister_lib(pi_device_binaries desc) {
+  (void)desc;
   // TODO implement the function
 }

sycl/source/detail/program_manager/program_manager.hpp

@@ -107,14 +107,13 @@ class ProgramManager {
   /// \param Prg the program object to get spec constant settings from.
   ///        Passing program_impl by raw reference is OK, since it is not
   ///        captured anywhere once the function returns.
-  /// \param Device the device assosiated with the native program
   /// \param NativePrg the native program, target for spec constant setting; if
   ///        not null then overrides the native program in Prg
   /// \param Img A source of the information about which constants need
   ///        setting and symboling->integer spec constnant ID mapping. If not
   ///        null, overrides native program->binary image binding maintained by
   ///        the program manager.
-  void flushSpecConstants(const program_impl &Prg, pi::PiDevice Device,
+  void flushSpecConstants(const program_impl &Prg,
                           pi::PiProgram NativePrg = nullptr,
                           const RTDeviceBinaryImage *Img = nullptr);
   uint32_t getDeviceLibReqMask(const RTDeviceBinaryImage &Img);

sycl/source/detail/scheduler/graph_builder.cpp

@@ -339,7 +339,7 @@ Command *Scheduler::GraphBuilder::insertMemoryMove(MemObjRecord *Record,
       AllocaCmdSrc =
           static_cast<AllocaSubBufCommand *>(AllocaCmdSrc)->getParentAlloca();
     else if (AllocaCmdSrc->getSYCLMemObj() != Req->MSYCLMemObj)
-      assert(!"Inappropriate alloca command.");
+      assert(false && "Inappropriate alloca command.");
   }
 
   Command *NewCmd = nullptr;
@@ -728,6 +728,7 @@ void Scheduler::GraphBuilder::markModifiedIfWrite(MemObjRecord *Record,
   case access::mode::discard_read_write:
   case access::mode::atomic:
     Record->MMemModified = true;
+    break;
   case access::mode::read:
     break;
   }

sycl/source/detail/stream_impl.cpp

@@ -19,6 +19,7 @@ namespace detail {
 stream_impl::stream_impl(size_t BufferSize, size_t MaxStatementSize,
                          handler &CGH)
     : BufferSize_(BufferSize), MaxStatementSize_(MaxStatementSize) {
+  (void)CGH;
   // We need to store stream buffers in the scheduler because they need to be
   // alive after submitting the kernel. They cannot be stored in the stream
   // object because it causes loop dependency between objects and results in

sycl/source/handler.cpp

@@ -103,9 +103,6 @@ event handler::finalize() {
     throw runtime_error("Command group submitted without a kernel or a "
                         "explicit memory operation.",
                         PI_INVALID_OPERATION);
-  default:
-    throw runtime_error("Unhandled type of command group",
-                        PI_INVALID_OPERATION);
   }
 
   detail::EventImplPtr Event = detail::Scheduler::getInstance().addCG(

sycl/source/spirv_ops.cpp

@@ -18,11 +18,17 @@
 __SYCL_EXPORT void __spirv_GroupWaitEvents(__spv::Scope Execution,
                                            uint32_t NumEvents,
                                            __ocl_event_t *WaitEvents) noexcept {
+  (void)Execution;
+  (void)NumEvents;
+  (void)WaitEvents;
 }
 
 __SYCL_EXPORT void __spirv_ControlBarrier(__spv::Scope Execution,
                                           __spv::Scope Memory,
                                           uint32_t Semantics) noexcept {
+  (void)Execution;
+  (void)Memory;
+  (void)Semantics;
   std::cerr << "Barrier is not supported on the host device yet.\n";
   abort();
 }
@@ -33,6 +39,8 @@ __SYCL_EXPORT void __spirv_MemoryBarrier(__spv::Scope Memory,
   //    separation to global and local there.
   // 2. The 'Semantics' parameter is ignored because there is no need
   //    to distinguish the classes of memory (workgroup/cross-workgroup/etc).
+  (void)Memory;
+  (void)Semantics;
   atomic_thread_fence(std::memory_order_seq_cst);
 }