Fix and improve translation of transmute

My earlier changes caused the result to be incorrect when both the input
and output types were immediate. This has been fixed. I also extended
the code to handle int -> ptr and ptr -> int casts as simple cases,
since it's fairly easy to do.

I changed the one place that was transmuting a function pointer to an
integer to just use a cast, it's more clear this way.

Author: Aatch

src/librustc_trans/trans/expr.rs

@@ -596,8 +596,9 @@ fn trans_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                         fty.abi == synabi::RustIntrinsic;
 
                     let needs_drop = type_needs_drop(bcx.tcx(), ret_ty);
+                    let uses_output = type_of::return_uses_outptr(bcx.ccx(), ret_ty);
 
-                    if is_rust_fn && type_is_immediate(bcx.ccx(), ret_ty) && !needs_drop {
+                    if is_rust_fn && !uses_output && !needs_drop {
                         let args = callee::ArgExprs(&args[..]);
                         let result = callee::trans_call_inner(bcx,
                                                               expr.debug_loc(),

src/librustc_trans/trans/intrinsic.rs

@@ -171,6 +171,8 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     let foreign_item = tcx.map.expect_foreign_item(node);
     let name = token::get_ident(foreign_item.ident);
 
+    let call_debug_location = DebugLoc::At(call_info.id, call_info.span);
+
     // For `transmute` we can just trans the input expr directly into dest
     if &name[..] == "transmute" {
         let llret_ty = type_of::type_of(ccx, ret_ty.unwrap());
@@ -199,14 +201,14 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                 };
 
                 // An approximation to which types can be directly cast via
-                // LLVM's bitcast.  This doesn't cover pointer -> pointer casts,
-                // but does, importantly, cover SIMD types.
+                // LLVM's bitcast.
                 let in_kind = llintype.kind();
                 let ret_kind = llret_ty.kind();
                 let bitcast_compatible =
-                    (nonpointer_nonaggregate(in_kind) && nonpointer_nonaggregate(ret_kind)) || {
-                        in_kind == TypeKind::Pointer && ret_kind == TypeKind::Pointer
-                    };
+                    (nonpointer_nonaggregate(in_kind) && nonpointer_nonaggregate(ret_kind)) ||
+                    (in_kind == TypeKind::Pointer && ret_kind == TypeKind::Pointer) ||
+                    (in_kind == TypeKind::Pointer && ret_kind == TypeKind::Integer) ||
+                    (in_kind == TypeKind::Integer && ret_kind == TypeKind::Pointer);
 
                 let val = if bitcast_compatible {
                     // if we're here, the type is scalar-like (a primitive, a
@@ -226,29 +228,62 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         from_arg_ty(bcx, datum.val, datum.ty)
                     };
 
-                    let cast_val = BitCast(bcx, val, llret_ty);
+                    // Do the appropriate cast type
+                    let cast_val = match (in_kind, ret_kind) {
+                        (TypeKind::Pointer, TypeKind::Pointer) => PointerCast(bcx, val, llret_ty),
+                        (TypeKind::Pointer, TypeKind::Integer) => PtrToInt(bcx, val, llret_ty),
+                        (TypeKind::Integer, TypeKind::Pointer) => IntToPtr(bcx, val, llret_ty),
+                        _ => BitCast(bcx, val, llret_ty)
+                    };
 
                     match dest {
                         expr::SaveIn(d) => {
                             // this often occurs in a sequence like `Store(val,
                             // d); val2 = Load(d)`, so disappears easily.
                             Store(bcx, cast_val, d);
-                            d
                         }
-                        expr::Ignore => { cast_val }
+                        expr::Ignore => {}
                     }
+                    cast_val
                 } else {
                     // The types are too complicated to do with a by-value
                     // bitcast, so pointer cast instead. We need to cast the
                     // dest so the types work out.
-                    let dest = match dest {
+
+                    // Create the destination, if we were passed a destination, bitcast it to the
+                    // appropriate type. Otherwise, create a temporary destination for immediate
+                    // types and just ignore non-immediate types. This is because we return the
+                    // result for immediate values.
+                    let tmp_dest = match dest {
                         expr::SaveIn(d) => expr::SaveIn(PointerCast(bcx, d, llintype.ptr_to())),
-                        expr::Ignore => expr::Ignore
+                        expr::Ignore => if type_is_immediate(bcx.ccx(), out_type) {
+                            expr::SaveIn(alloc_ty(bcx, in_type, "intrinsic_result"))
+                        } else {
+                            expr::Ignore
+                        }
                     };
-                    bcx = expr::trans_into(bcx, &*arg_exprs[0], dest);
+                    bcx = expr::trans_into(bcx, &*arg_exprs[0], tmp_dest);
                     match dest {
                         expr::SaveIn(d) => d,
-                        expr::Ignore => C_undef(llret_ty)
+                        expr::Ignore => {
+                            // We weren't passed a destination to save to, if we made a temporary
+                            // destination, load the immediate value stored and clean up the type.
+                            // Otherwise return ().
+                            if let expr::SaveIn(d) = tmp_dest {
+                                let val = if type_is_immediate(bcx.ccx(), out_type) {
+                                    let d = PointerCast(bcx, d, llouttype.ptr_to());
+                                    load_ty(bcx, d, out_type)
+                                } else {
+                                    C_nil(bcx.ccx())
+                                };
+
+                                bcx = glue::drop_ty(bcx, d, out_type, call_debug_location);
+
+                                val
+                            } else {
+                                C_nil(bcx.ccx())
+                            }
+                        }
                     }
                 };
 
@@ -320,8 +355,6 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
 
     fcx.scopes.borrow_mut().last_mut().unwrap().drop_non_lifetime_clean();
 
-    let call_debug_location = DebugLoc::At(call_info.id, call_info.span);
-
     // These are the only intrinsic functions that diverge.
     if &name[..] == "abort" {
         let llfn = ccx.get_intrinsic(&("llvm.trap"));

src/libstd/rt/unwind/mod.rs

@@ -306,7 +306,7 @@ pub unsafe fn register(f: Callback) -> bool {
         // been incremented, but the callback has not been stored. We're
         // guaranteed that the slot we're storing into is 0.
         n if n < MAX_CALLBACKS => {
-            let prev = CALLBACKS[n].swap(mem::transmute(f), Ordering::SeqCst);
+            let prev = CALLBACKS[n].swap(f as usize, Ordering::SeqCst);
             rtassert!(prev == 0);
             true
         }