[SYCL] Coverity bug fix

sycl/include/sycl/functional.hpp

@@ -35,36 +35,39 @@ template <typename T = void> struct logical_or {
 
 template <> struct logical_or<void> : std::logical_or<void> {};
 
+// sycl::minimum definition should be consistent with std::min
 template <typename T = void> struct minimum {
   T operator()(const T &lhs, const T &rhs) const {
-    return std::less<T>()(lhs, rhs) ? lhs : rhs;
+    return (rhs < lhs) ? rhs : lhs;
   }
 };
 
 template <> struct minimum<void> {
   struct is_transparent {};
   template <typename T, typename U>
-  auto operator()(T &&lhs, U &&rhs) const -> std::common_type_t<T &&, U &&> {
-    return std::less<>()(std::forward<const T>(lhs), std::forward<const U>(rhs))
-               ? std::forward<T>(lhs)
-               : std::forward<U>(rhs);
+  auto operator()(T &&lhs, U &&rhs) const ->
+      typename std::common_type<T &&, U &&>::type {
+    return (std::forward<const U>(rhs) < std::forward<const T>(lhs))
+               ? std::forward<U>(rhs)
+               : std::forward<T>(lhs);
   }
 };
 
+// sycl::maximum definition should be consistent with std::max
 template <typename T = void> struct maximum {
   T operator()(const T &lhs, const T &rhs) const {
-    return std::greater<T>()(lhs, rhs) ? lhs : rhs;
+    return (lhs < rhs) ? rhs : lhs;
   }
 };
 
 template <> struct maximum<void> {
   struct is_transparent {};
   template <typename T, typename U>
-  auto operator()(T &&lhs, U &&rhs) const -> std::common_type_t<T &&, U &&> {
-    return std::greater<>()(std::forward<const T>(lhs),
-                            std::forward<const U>(rhs))
-               ? std::forward<T>(lhs)
-               : std::forward<U>(rhs);
+  auto operator()(T &&lhs, U &&rhs) const ->
+      typename std::common_type<T &&, U &&>::type {
+    return (std::forward<const T>(lhs) < std::forward<const U>(rhs))
+               ? std::forward<U>(rhs)
+               : std::forward<T>(lhs);
   }
 };
 

sycl/source/detail/global_handler.hpp

@@ -54,6 +54,7 @@ class GlobalHandler {
 
   GlobalHandler(const GlobalHandler &) = delete;
   GlobalHandler(GlobalHandler &&) = delete;
+  GlobalHandler &operator=(const GlobalHandler &) = delete;
 
   void registerSchedulerUsage(bool ModifyCounter = true);
   Scheduler &getScheduler();

sycl/source/detail/program_impl.cpp

@@ -184,9 +184,6 @@ program_impl::program_impl(ContextImplPtr Context,
       OptionsVector.data(), nullptr);
   std::string Options(OptionsVector.begin(), OptionsVector.end());
   switch (BinaryType) {
-  case PI_PROGRAM_BINARY_TYPE_NONE:
-    assert(false);
-    break;
   case PI_PROGRAM_BINARY_TYPE_COMPILED_OBJECT:
     MState = program_state::compiled;
     MCompileOptions = Options;

sycl/source/detail/scheduler/commands.cpp

@@ -70,6 +70,20 @@ bool CurrentCodeLocationValid() {
 struct DemangleHandle {
   char *p;
   DemangleHandle(char *ptr) : p(ptr) {}
+
+  DemangleHandle &operator=(const DemangleHandle &rhs) {
+    if (this == &rhs)
+      return *this;
+
+    std::size_t n{std::strlen(rhs.p) + 1};
+    char *new_p = new char[n];
+    std::memcpy(new_p, rhs.p, n);
+    delete[] p;
+    p = new_p;
+
+    return *this;
+  }
+
   ~DemangleHandle() { std::free(p); }
 };
 static std::string demangleKernelName(std::string Name) {

sycl/source/detail/scheduler/leaves_collection.hpp

@@ -221,6 +221,18 @@ class LeavesCollection {
               (!MGenericIsActive && MHACIt != Rhs.MHACIt));
     }
 
+    IteratorT &operator=(const IteratorT<IsConst> &Rhs) {
+      if (this == &Rhs)
+        return *this;
+
+      MHost = Rhs.MHost;
+      MGCIt = Rhs.MGCIt;
+      MHACIt = Rhs.MHACIt;
+      MGenericIsActive = Rhs.MGenericIsActive;
+
+      return *this;
+    }
+
     // pre-increment
     IteratorT<IsConst> &operator++() {
       increment();

sycl/test/basic_tests/sycl_maximum_minimum.cpp

@@ -0,0 +1,25 @@
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: %t.out
+#include <sycl/sycl.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <limits>
+
+int main() {
+  double f1 = 1.0f;
+  double f2 = std::numeric_limits<double>::quiet_NaN();
+
+  assert(((std::max(f1, f2) == sycl::maximum{}(f1, f2)) &&
+          "sycl::maximum result is wrong"));
+  assert(((std::isnan((std::max(f2, f1)))) &&
+          (std::isnan(sycl::maximum{}(f2, f1)))) &&
+         "sycl::maximum result is wrong");
+  assert(((std::min(f1, f2) == sycl::minimum{}(f1, f2)) &&
+          "sycl::minimum result is wrong"));
+  assert(((std::isnan((std::min(f2, f1)))) &&
+          (std::isnan(sycl::minimum{}(f2, f1)))) &&
+         "sycl::minimum result is wrong");
+
+  return 0;
+}

xpti/src/xpti_proxy.cpp

@@ -91,6 +91,12 @@ class ProxyLoader {
     tryToEnable();
   }
 
+  ProxyLoader(bool loaded, xpti_plugin_handle_t fw_plugin_handle)
+      : m_loaded(loaded), m_fw_plugin_handle(fw_plugin_handle) {}
+
+  ProxyLoader(const ProxyLoader &rhs)
+      : ProxyLoader(rhs.m_loaded, rhs.m_fw_plugin_handle) {}
+
   ~ProxyLoader() {
     // If the loading of the framework library was
     // successful, we should close the handle in the