Implement send_unverified for each platform

This allows fixing an issue where gnustep was not returning correctly
zeroed floating point results when messaging nil.

Author: SSheldon

src/message/apple/arm.rs

@@ -1,47 +1,40 @@
 use std::any::{Any, TypeId};
 use std::mem;
 
-use runtime::{Object, Imp, Sel};
-use super::Super;
+use runtime::Imp;
 
-pub fn msg_send_fn<R: Any>(obj: *mut Object, _: Sel) -> (Imp, *mut Object) {
+extern {
+    fn objc_msgSend();
+    fn objc_msgSend_stret();
+
+    fn objc_msgSendSuper();
+    fn objc_msgSendSuper_stret();
+}
+
+pub fn msg_send_fn<R: Any>() -> Imp {
     // Double-word sized fundamental data types don't use stret,
     // but any composite type larger than 4 bytes does.
     // <http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042e/IHI0042E_aapcs.pdf>
 
-    extern {
-        fn objc_msgSend();
-        fn objc_msgSend_stret();
-    }
-
     let type_id = TypeId::of::<R>();
-    let msg_fn = if mem::size_of::<R>() <= 4 ||
+    if mem::size_of::<R>() <= 4 ||
             type_id == TypeId::of::<i64>() ||
             type_id == TypeId::of::<u64>() ||
             type_id == TypeId::of::<f64>() {
         objc_msgSend
     } else {
         objc_msgSend_stret
-    };
-
-    (msg_fn, obj)
-}
-
-pub fn msg_send_super_fn<R: Any>(sup: &Super, _: Sel) -> (Imp, *mut Object) {
-    extern {
-        fn objc_msgSendSuper();
-        fn objc_msgSendSuper_stret();
     }
+}
 
+pub fn msg_send_super_fn<R: Any>() -> Imp {
     let type_id = TypeId::of::<R>();
-    let msg_fn = if mem::size_of::<R>() <= 4 ||
+    if mem::size_of::<R>() <= 4 ||
             type_id == TypeId::of::<i64>() ||
             type_id == TypeId::of::<u64>() ||
             type_id == TypeId::of::<f64>() {
         objc_msgSendSuper
     } else {
         objc_msgSendSuper_stret
-    };
-
-    (msg_fn, sup as *const Super as *mut Object)
+    }
 }

src/message/apple/arm64.rs

@@ -1,21 +1,18 @@
-use runtime::{Object, Imp, Sel};
-use super::Super;
+use runtime::Imp;
 
-pub fn msg_send_fn<R>(obj: *mut Object, _: Sel) -> (Imp, *mut Object) {
+extern {
+    fn objc_msgSend();
+
+    fn objc_msgSendSuper();
+}
+
+pub fn msg_send_fn<R>() -> Imp {
     // stret is not even available in arm64.
     // <https://twitter.com/gparker/status/378079715824660480>
 
-    extern {
-        fn objc_msgSend();
-    }
-
-    (objc_msgSend, obj)
+    objc_msgSend
 }
 
-pub fn msg_send_super_fn<R>(sup: &Super, _: Sel) -> (Imp, *mut Object) {
-    extern {
-        fn objc_msgSendSuper();
-    }
-
-    (objc_msgSendSuper, sup as *const Super as *mut Object)
+pub fn msg_send_super_fn<R>() -> Imp {
+    objc_msgSendSuper
 }

src/message/apple/mod.rs

@@ -1,4 +1,7 @@
-use super::Super;
+use std::any::Any;
+
+use runtime::{Class, Object, Sel};
+use super::{Message, MessageArguments, MessageError, Super};
 
 #[cfg(target_arch = "x86")]
 #[path = "x86.rs"]
@@ -13,4 +16,25 @@ mod arch;
 #[path = "arm64.rs"]
 mod arch;
 
-pub use self::arch::{msg_send_fn, msg_send_super_fn};
+use self::arch::{msg_send_fn, msg_send_super_fn};
+
+pub unsafe fn send_unverified<T, A, R>(obj: *const T, sel: Sel, args: A)
+        -> Result<R, MessageError>
+        where T: Message, A: MessageArguments, R: Any {
+    let receiver = obj as *mut T as *mut Object;
+    let msg_send_fn = msg_send_fn::<R>();
+    objc_try!({
+        A::invoke(msg_send_fn, receiver, sel, args)
+    })
+}
+
+pub unsafe fn send_super_unverified<T, A, R>(obj: *const T, superclass: &Class,
+        sel: Sel, args: A) -> Result<R, MessageError>
+        where T: Message, A: MessageArguments, R: Any {
+    let sup = Super { receiver: obj as *mut T as *mut Object, superclass: superclass };
+    let receiver = &sup as *const Super as *mut Object;
+    let msg_send_fn = msg_send_super_fn::<R>();
+    objc_try!({
+        A::invoke(msg_send_fn, receiver, sel, args)
+    })
+}

src/message/apple/x86.rs

@@ -1,47 +1,40 @@
 use std::any::{Any, TypeId};
 use std::mem;
 
-use runtime::{Object, Imp, Sel};
-use super::Super;
+use runtime::Imp;
 
-pub fn msg_send_fn<R: Any>(obj: *mut Object, _: Sel) -> (Imp, *mut Object) {
+extern {
+    fn objc_msgSend();
+    fn objc_msgSend_fpret();
+    fn objc_msgSend_stret();
+
+    fn objc_msgSendSuper();
+    fn objc_msgSendSuper_stret();
+}
+
+pub fn msg_send_fn<R: Any>() -> Imp {
     // Structures 1 or 2 bytes in size are placed in EAX.
     // Structures 4 or 8 bytes in size are placed in: EAX and EDX.
     // Structures of other sizes are placed at the address supplied by the caller.
     // <https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/LowLevelABI/130-IA-32_Function_Calling_Conventions/IA32.html>
 
-    extern {
-        fn objc_msgSend();
-        fn objc_msgSend_fpret();
-        fn objc_msgSend_stret();
-    }
-
     let type_id = TypeId::of::<R>();
     let size = mem::size_of::<R>();
-    let msg_fn = if type_id == TypeId::of::<f32>() ||
+    if type_id == TypeId::of::<f32>() ||
             type_id == TypeId::of::<f64>() {
         objc_msgSend_fpret
     } else if size == 0 || size == 1 || size == 2 || size == 4 || size == 8 {
         objc_msgSend
     } else {
         objc_msgSend_stret
-    };
-
-    (msg_fn, obj)
-}
-
-pub fn msg_send_super_fn<R: Any>(sup: &Super, _: Sel) -> (Imp, *mut Object) {
-    extern {
-        fn objc_msgSendSuper();
-        fn objc_msgSendSuper_stret();
     }
+}
 
+pub fn msg_send_super_fn<R: Any>() -> Imp {
     let size = mem::size_of::<R>();
-    let msg_fn = if size == 0 || size == 1 || size == 2 || size == 4 || size == 8 {
+    if size == 0 || size == 1 || size == 2 || size == 4 || size == 8 {
         objc_msgSendSuper
     } else {
         objc_msgSendSuper_stret
-    };
-
-    (msg_fn, sup as *const Super as *mut Object)
+    }
 }

src/message/apple/x86_64.rs

@@ -1,39 +1,32 @@
 use std::mem;
 
-use runtime::{Object, Imp, Sel};
-use super::Super;
+use runtime::Imp;
 
-pub fn msg_send_fn<R>(obj: *mut Object, _: Sel) -> (Imp, *mut Object) {
+extern {
+    fn objc_msgSend();
+    fn objc_msgSend_stret();
+
+    fn objc_msgSendSuper();
+    fn objc_msgSendSuper_stret();
+}
+
+pub fn msg_send_fn<R>() -> Imp {
     // If the size of an object is larger than two eightbytes, it has class MEMORY.
     // If the type has class MEMORY, then the caller provides space for the return
     // value and passes the address of this storage.
     // <http://people.freebsd.org/~obrien/amd64-elf-abi.pdf>
 
-    extern {
-        fn objc_msgSend();
-        fn objc_msgSend_stret();
-    }
-
-    let msg_fn = if mem::size_of::<R>() <= 16 {
+    if mem::size_of::<R>() <= 16 {
         objc_msgSend
     } else {
         objc_msgSend_stret
-    };
-
-    (msg_fn, obj)
-}
-
-pub fn msg_send_super_fn<R>(sup: &Super, _: Sel) -> (Imp, *mut Object) {
-    extern {
-        fn objc_msgSendSuper();
-        fn objc_msgSendSuper_stret();
     }
+}
 
-    let msg_fn = if mem::size_of::<R>() <= 16 {
+pub fn msg_send_super_fn<R>() -> Imp {
+    if mem::size_of::<R>() <= 16 {
         objc_msgSendSuper
     } else {
         objc_msgSendSuper_stret
-    };
-
-    (msg_fn, sup as *const Super as *mut Object)
+    }
 }

src/message/gnustep.rs

@@ -1,24 +1,35 @@
-use runtime::{Object, Imp, Sel};
-use super::Super;
+use std::any::Any;
+use std::mem;
 
-pub fn msg_send_fn<R>(obj: *mut Object, sel: Sel) -> (Imp, *mut Object) {
-    extern {
-        fn objc_msg_lookup(receiver: *mut Object, op: Sel) -> Imp;
-    }
+use runtime::{Class, Object, Imp, Sel};
+use super::{Message, MessageArguments, MessageError, Super};
 
-    let imp_fn = unsafe {
-        objc_msg_lookup(obj, sel)
-    };
-    (imp_fn, obj)
+extern {
+    fn objc_msg_lookup(receiver: *mut Object, op: Sel) -> Imp;
+    fn objc_msg_lookup_super(sup: *const Super, sel: Sel) -> Imp;
 }
 
-pub fn msg_send_super_fn<R>(sup: &Super, sel: Sel) -> (Imp, *mut Object) {
-    extern {
-        fn objc_msg_lookup_super(sup: *const Super, sel: Sel) -> Imp;
+pub unsafe fn send_unverified<T, A, R>(obj: *const T, sel: Sel, args: A)
+        -> Result<R, MessageError>
+        where T: Message, A: MessageArguments, R: Any {
+    if obj.is_null() {
+        return mem::zeroed();
     }
 
-    let imp_fn = unsafe {
-        objc_msg_lookup_super(sup, sel)
-    };
-    (imp_fn, sup.receiver)
+    let receiver = obj as *mut T as *mut Object;
+    let msg_send_fn = objc_msg_lookup(receiver, sel);
+    objc_try!({
+        A::invoke(msg_send_fn, receiver, sel, args)
+    })
+}
+
+pub unsafe fn send_super_unverified<T, A, R>(obj: *const T, superclass: &Class,
+        sel: Sel, args: A) -> Result<R, MessageError>
+        where T: Message, A: MessageArguments, R: Any {
+    let receiver = obj as *mut T as *mut Object;
+    let sup = Super { receiver: receiver, superclass: superclass };
+    let msg_send_fn = objc_msg_lookup_super(&sup, sel);
+    objc_try!({
+        A::invoke(msg_send_fn, receiver, sel, args)
+    })
 }

src/message/mod.rs

@@ -6,6 +6,21 @@ use std::mem;
 use runtime::{Class, Imp, Object, Sel};
 use {Encode, EncodeArguments};
 
+#[cfg(feature = "exception")]
+macro_rules! objc_try {
+    ($b:block) => (
+        $crate::exception::try(|| $b).map_err(|exception| match exception {
+            Some(exception) => MessageError(format!("Uncaught exception {:?}", &*exception)),
+            None => MessageError("Uncaught exception nil".to_owned()),
+        })
+    )
+}
+
+#[cfg(not(feature = "exception"))]
+macro_rules! objc_try {
+    ($b:block) => (Ok($b))
+}
+
 mod verify;
 
 #[cfg(any(target_os = "macos", target_os = "ios"))]
@@ -15,7 +30,7 @@ mod platform;
 #[path = "gnustep.rs"]
 mod platform;
 
-use self::platform::{msg_send_fn, msg_send_super_fn};
+use self::platform::{send_unverified, send_super_unverified};
 use self::verify::verify_message_signature;
 
 /// Specifies the superclass of an instance.
@@ -151,30 +166,6 @@ impl Error for MessageError {
     }
 }
 
-#[cfg(feature = "exception")]
-macro_rules! objc_try {
-    ($b:block) => (
-        $crate::exception::try(|| $b).map_err(|exception| match exception {
-            Some(exception) => MessageError(format!("Uncaught exception {:?}", &*exception)),
-            None => MessageError("Uncaught exception nil".to_owned()),
-        })
-    )
-}
-
-#[cfg(not(feature = "exception"))]
-macro_rules! objc_try {
-    ($b:block) => (Ok($b))
-}
-
-unsafe fn send_unverified<T, A, R>(obj: *const T, sel: Sel, args: A)
-        -> Result<R, MessageError>
-        where T: Message, A: MessageArguments, R: Any {
-    let (msg_send_fn, receiver) = msg_send_fn::<R>(obj as *mut T as *mut Object, sel);
-    objc_try!({
-        A::invoke(msg_send_fn, receiver, sel, args)
-    })
-}
-
 #[doc(hidden)]
 #[inline(always)]
 #[cfg(not(feature = "verify_message"))]
@@ -202,16 +193,6 @@ pub unsafe fn send_message<T, A, R>(obj: *const T, sel: Sel, args: A)
     })
 }
 
-unsafe fn send_super_unverified<T, A, R>(obj: *const T, superclass: &Class,
-        sel: Sel, args: A) -> Result<R, MessageError>
-        where T: Message, A: MessageArguments, R: Any {
-    let sup = Super { receiver: obj as *mut T as *mut Object, superclass: superclass };
-    let (msg_send_fn, receiver) = msg_send_super_fn::<R>(&sup, sel);
-    objc_try!({
-        A::invoke(msg_send_fn, receiver, sel, args)
-    })
-}
-
 #[doc(hidden)]
 #[inline(always)]
 #[cfg(not(feature = "verify_message"))]