1 files changed, 34 insertions, 13 deletions

diff --git a/src/vxworks/mod.rs b/src/vxworks/mod.rs
index 77d8955936..f1aff9d4bd 100755
--- a/src/vxworks/mod.rs
+++ b/src/vxworks/mod.rs
@@ -416,9 +416,9 @@ s_no_extra_traits! {
     }
 
     pub union sa_u_t {
-        pub sa_handler : extern "C" fn(::c_int) -> !,
-        pub sa_sigaction: extern "C" fn(::c_int, *mut ::siginfo_t,
-                                        *mut ::c_void) -> !,
+        pub sa_handler : Option<unsafe extern "C" fn(::c_int) -> !>,
+        pub sa_sigaction: Option<unsafe extern "C" fn(::c_int, *mut ::siginfo_t,
+                                        *mut ::c_void) -> !>,
     }
 
     pub union sigval {
@@ -477,41 +477,62 @@ cfg_if! {
 
         impl PartialEq for sa_u_t {
             fn eq(&self, other: &sa_u_t) -> bool {
-                unsafe { self.sa_handler == other.sa_handler }
+                unsafe {
+                    let h1 = match self.sa_handler {
+                        Some(handler) => handler as usize,
+                        None => 0 as usize,
+                    };
+                    let h2 = match other.sa_handler {
+                        Some(handler) => handler as usize,
+                        None => 0 as usize,
+                    };
+                    h1 == h2
+                }
             }
         }
         impl Eq for sa_u_t {}
         impl ::fmt::Debug for sa_u_t {
             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
-                f.debug_struct("sa_u_t")
-                    .field("sa_handler", unsafe { &self.sa_handler })
-                    .field("sa_sigaction", unsafe { &self.sa_sigaction })
-                    .finish()
+                unsafe {
+                    let h = match self.sa_handler {
+                        Some(handler) => handler as usize,
+                        None => 0 as usize,
+                    };
+
+                    f.debug_struct("sa_u_t")
+                        .field("sa_handler", &h)
+                        .finish()
+                }
             }
         }
         impl ::hash::Hash for sa_u_t {
             fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
-                unsafe { self.sa_handler.hash(state) };
+                unsafe {
+                    let h = match self.sa_handler {
+                        Some(handler) => handler as usize,
+                        None => 0 as usize,
+                    };
+                    h.hash(state)
+                }
             }
         }
 
         impl PartialEq for sigval {
             fn eq(&self, other: &sigval) -> bool {
-                unsafe { self.sival_ptr == other.sival_ptr }
+                unsafe { self.sival_ptr as usize == other.sival_ptr as usize }
             }
         }
         impl Eq for sigval {}
         impl ::fmt::Debug for sigval {
             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                 f.debug_struct("sigval")
-                    .field("sival_int", unsafe { &self.sival_int})
-                    .field("sival_ptr", unsafe { &self.sival_ptr })
+                    .field("sival_ptr", unsafe { &(self.sival_ptr as usize) })
                     .finish()
             }
         }
         impl ::hash::Hash for sigval {
             fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
-                unsafe { self.sival_ptr.hash(state) };
+                unsafe { (self.sival_ptr as usize).hash(state) };
             }
         }
     }