 diff --git a/src/librustc/mir/repr.rs b/src/librustc/mir/repr.rs
 index 049063f..38fb55f 100644
 --- a/src/librustc/mir/repr.rs
 +++ b/src/librustc/mir/repr.rs
 @@ -294,7 +294,7 @@ impl<'tcx> Terminator<'tcx> {
     }
 }
 
 -#[derive(Debug, RustcEncodable, RustcDecodable)]
 +#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
 pub struct CallData<'tcx> {
     /// where the return value is written to
     pub destination: Lvalue<'tcx>,
 @@ -609,6 +609,8 @@ pub enum CastKind {
     /// `&[i32;N]` to a `&[i32]`, or a `Box<T>` to a `Box<Trait>`
     /// (presuming `T: Trait`).
     Unsize,
 +
 +    Transmute,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
 diff --git a/src/librustc_mir/mir_map.rs b/src/librustc_mir/mir_map.rs
 index 39a315f..39a94e2 100644
 --- a/src/librustc_mir/mir_map.rs
 +++ b/src/librustc_mir/mir_map.rs
 @@ -145,6 +145,7 @@ impl<'a, 'm, 'tcx> Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
 
         match build_mir(Cx::new(&infcx), implicit_arg_tys, id, span, decl, body) {
             Ok(mut mir) => {
 +                lower_intrinsics::LowerIntrinsics::new(self.tcx).run_on_mir(&mut mir);
                 simplify_cfg::SimplifyCfg::new().run_on_mir(&mut mir);
 
                 let meta_item_list = self.attr
 diff --git a/src/librustc_mir/transform/lower_intrinsics.rs b/src/librustc_mir/transform/lower_intrinsics.rs
 new file mode 100644
 index 0000000..45da514
 --- /dev/null
 +++ b/src/librustc_mir/transform/lower_intrinsics.rs
 @@ -0,0 +1,133 @@
 +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
 +// file at the top-level directory of this distribution and at
 +// http://rust-lang.org/COPYRIGHT.
 +//
 +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 +// option. This file may not be copied, modified, or distributed
 +// except according to those terms.
 +
 +//! This pass lowers any Call terminators which are intrinsics
 +//! to whatever statements or other calls as necessary.
 +
 +use transform::MirPass;
 +
 +use rustc::middle::infer;
 +use rustc::middle::ty;
 +use rustc::mir::repr::*;
 +use rustc::mir::repr::Terminator::Call;
 +
 +use syntax::abi;
 +
 +
 +pub struct LowerIntrinsics<'a, 'tcx: 'a> {
 +    tcx: &'a ty::ctxt<'tcx>
 +}
 +
 +impl<'a, 'tcx: 'a> LowerIntrinsics<'a, 'tcx>  {
 +    pub fn new(tcx: &'a ty::ctxt<'tcx>) -> LowerIntrinsics<'a, 'tcx> {
 +        LowerIntrinsics { tcx: tcx }
 +    }
 +}
 +
 +impl<'a, 'tcx> MirPass<'tcx> for LowerIntrinsics<'a, 'tcx> {
 +    fn run_on_mir(&mut self, mir: &mut Mir<'tcx>) {
 +        let mut bbs = vec![];
 +
 +        for (i, basic_block) in mir.basic_blocks.iter_mut().enumerate() {
 +            match basic_block.terminator {
 +                Call { ref data, .. } if is_intrinsic_call(data) => bbs.push(BasicBlock::new(i)),
 +                _ => {}
 +            }
 +        }
 +
 +        for bb in bbs {
 +            lower_intrinsic_in_basic_block(self.tcx, mir, bb);
 +        }
 +    }
 +}
 +
 +fn is_intrinsic_call<'tcx>(call_data: &CallData<'tcx>) -> bool {
 +    if let Operand::Constant(Constant { ty, .. }) = call_data.func {
 +        match ty.sty {
 +            ty::TyBareFn(_, fty) if fty.abi == abi::RustIntrinsic => true,
 +            _ => false
 +        }
 +    } else {
 +        false
 +    }
 +}
 +
 +fn lower_intrinsic_in_basic_block<'tcx>(tcx: &ty::ctxt<'tcx>,
 +                                        mir: &mut Mir<'tcx>,
 +                                        bb: BasicBlock) {
 +
 +    let basic_block = mir.basic_block_data_mut(bb);
 +
 +    let (call_data, targets) =
 +        if let Call { ref data, targets } = basic_block.terminator {
 +            ((*data).clone(), targets)
 +        } else {
 +            tcx.sess.bug("expected `Call` terminator to lower intrinsic")
 +        };
 +    let (def_id, span, fty) = if let Operand::Constant(Constant {
 +        span, ty, literal: Literal::Item { def_id, .. }
 +    }) = call_data.func {
 +        (def_id, span, ty)
 +    } else {
 +        tcx.sess.bug("could not get literal item to lower intrinsic")
 +    };
 +
 +    let sig = tcx.erase_late_bound_regions(&fty.fn_sig());
 +    let sig = infer::normalize_associated_type(tcx, &sig);
 +    let ret_ty = sig.output.unwrap_or(tcx.mk_nil());
 +
 +    let name = &*tcx.item_name(def_id).as_str();
 +
 +    if name == "transmute" {
 +
 +        assert_eq!(call_data.args.len(), 1);
 +
 +        // dest = transmute(foo)
 +        //   =>
 +        // Assign(dest, Cast(foo))
 +        basic_block.statements.push(Statement {
 +            span: span,
 +            kind: StatementKind::Assign(
 +                call_data.destination.clone(),
 +                Rvalue::Cast(CastKind::Transmute,
 +                             call_data.args[0].clone(),
 +                             ret_ty)
 +            )
 +        });
 +
 +        // Since this is no longer a function call, replace the
 +        // terminator with a simple Goto
 +        basic_block.terminator = Terminator::Goto { target: targets.0 };
 +
 +    } else if name == "move_val_init" {
 +
 +        assert_eq!(call_data.args.len(), 2);
 +
 +        if let Operand::Consume(dest) = call_data.args[0].clone() {
 +            // move_val_init(dest, src)
 +            //   =>
 +            // Assign(dest, src)
 +            basic_block.statements.push(Statement {
 +                span: span,
 +                kind: StatementKind::Assign(
 +                    dest,
 +                    Rvalue::Use(call_data.args[1].clone())
 +                )
 +            });
 +        } else {
 +            tcx.sess.span_bug(span, "destination argument not lvalue?");
 +        }
 +
 +        // Since this is no longer a function call, replace the
 +        // terminator with a simple Goto
 +        basic_block.terminator = Terminator::Goto { target: targets.0 };
 +
 +    }
 +}
 diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs
 index 174718f..6b37e01 100644
 --- a/src/librustc_mir/transform/mod.rs
 +++ b/src/librustc_mir/transform/mod.rs
 @@ -10,6 +10,7 @@
 
 pub mod simplify_cfg;
 pub mod erase_regions;
 +pub mod lower_intrinsics;
 mod util;
 
 use rustc::mir::repr::Mir;
 diff --git a/src/librustc_trans/trans/mir/rvalue.rs b/src/librustc_trans/trans/mir/rvalue.rs
 index 529e65d..1dc14f2 100644
 --- a/src/librustc_trans/trans/mir/rvalue.rs
 +++ b/src/librustc_trans/trans/mir/rvalue.rs
 @@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
 -use llvm::ValueRef;
 +use llvm::{TypeKind, ValueRef};
 use rustc::middle::ty::{self, Ty};
 use rustc::mir::repr as mir;
 
 use trans::asm;
 use trans::base;
 -use trans::build;
 +use trans::build::{self, BitCast, IntToPtr, PointerCast, PtrToInt};
 use trans::common::{self, Block, Result};
 use trans::debuginfo::DebugLoc;
 use trans::declare;
 @@ -140,6 +140,8 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
     {
         assert!(rvalue_creates_operand(rvalue), "cannot trans {:?} to operand", rvalue);
 
 +        let ccx = bcx.ccx();
 +        let tcx = bcx.tcx();
         match *rvalue {
             mir::Rvalue::Use(ref operand) => {
                 let operand = self.trans_operand(bcx, operand);
 @@ -185,7 +187,86 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
                             }
                         }
                     }
 -                    mir::CastKind::Misc => unimplemented!()
 +                    mir::CastKind::Misc => unimplemented!(),
 +                    mir::CastKind::Transmute => {
 +                        use trans::common::{type_is_fat_ptr, type_is_immediate};
 +
 +                        let llval_ty =  type_of::type_of(bcx.ccx(), operand.ty);
 +                        let llcast_ty = type_of::type_of(bcx.ccx(), cast_ty);
 +
 +                        assert_eq!(machine::llbitsize_of_real(bcx.ccx(), llval_ty),
 +                                   machine::llbitsize_of_real(bcx.ccx(), llcast_ty));
 +
 +                        let nonpointer_nonaggregate = |llkind: TypeKind| -> bool {
 +                            use llvm::TypeKind::*;
 +                            match llkind {
 +                                Half | Float | Double | X86_FP80 | FP128 |
 +                                    PPC_FP128 | Integer | Vector | X86_MMX => true,
 +                                _ => false
 +                            }
 +                        };
 +
 +                        let val_kind = llval_ty.kind();
 +                        let cast_kind = llcast_ty.kind();
 +
 +                        match operand.val {
 +                            // Cast Ref => Fat Ptr
 +                            // ex: (*const T, usize) => &[T]
 +                            OperandValue::Ref(r) if type_is_fat_ptr(tcx, cast_ty) => {
 +                                let (data, extra) = base::load_fat_ptr(bcx, r, cast_ty);
 +                                OperandValue::FatPtr(data, extra)
 +                            },
 +
 +                            // Cast Ref => Ref
 +                            // ex: &StructA => &StructB
 +                            OperandValue::Ref(r) => {
 +                                assert!(!type_is_immediate(ccx, cast_ty));
 +                                OperandValue::Ref(PointerCast(bcx, r, llcast_ty.ptr_to()))
 +                            },
 +
 +                            // Cast Immediate => Immediate
 +                            OperandValue::Immediate(i) => {
 +                                assert!(type_is_immediate(ccx, cast_ty));
 +                                let val = match (val_kind, cast_kind) {
 +                                    (TypeKind::Pointer, TypeKind::Integer) =>
 +                                        PtrToInt(bcx, i, llcast_ty),
 +
 +                                    (TypeKind::Integer, TypeKind::Pointer) =>
 +                                        IntToPtr(bcx, i, llcast_ty),
 +
 +                                    (TypeKind::Pointer, TypeKind::Pointer) =>
 +                                        PointerCast(bcx, i, llcast_ty),
 +
 +                                    _ if nonpointer_nonaggregate(val_kind) &&
 +                                         nonpointer_nonaggregate(cast_kind) => {
 +                                        BitCast(bcx, i, llcast_ty)
 +                                    },
 +
 +                                    _ => {
 +                                        let lltemp = base::alloc_ty(bcx, cast_ty, "__transmute_temp");
 +                                        let lldest = PointerCast(bcx, lltemp, llval_ty.ptr_to());
 +                                        base::store_ty(bcx, i, lldest, operand.ty);
 +                                        base::load_ty(bcx, lltemp, cast_ty)
 +                                    }
 +                                };
 +                                OperandValue::Immediate(val)
 +                            },
 +
 +                            // Fat Ptr => Fat Ptr
 +                            OperandValue::FatPtr(_, _) if type_is_fat_ptr(tcx, cast_ty)
 +                                => operand.val,
 +
 +                            // Fat Ptr => Ref
 +                            // ex: &[T] => (*const T, usize)
 +                            OperandValue::FatPtr(d, e) => {
 +                                assert!(!type_is_immediate(ccx, cast_ty));
 +                                let lltemp = base::alloc_ty(bcx, cast_ty, "__transmute_temp");
 +                                let lldest = PointerCast(bcx, lltemp, llval_ty.ptr_to());
 +                                base::store_fat_ptr(bcx, d, e, lldest, operand.ty);
 +                                OperandValue::Ref(lltemp)
 +                            }
 +                        }
 +                    }
                 };
                 (bcx, OperandRef {
                     val: val,