// Copyright 2012-2013 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.


use back::{link, abi};
use lib::llvm::{Pointer, ValueRef};
use lib;
use middle::trans::base::*;
use middle::trans::cabi;
use middle::trans::cabi_x86;
use middle::trans::cabi_x86_64;
use middle::trans::cabi_arm;
use middle::trans::cabi_mips;
use middle::trans::build::*;
use middle::trans::callee::*;
use middle::trans::common::*;
use middle::trans::datum::*;
use middle::trans::expr::Ignore;
use middle::trans::machine::llsize_of;
use middle::trans::glue;
use middle::trans::machine;
use middle::trans::type_of::*;
use middle::trans::type_of;
use middle::ty;
use middle::ty::FnSig;
use util::ppaux::ty_to_str;

use std::cell::Cell;
use std::uint;
use std::vec;
use syntax::codemap::span;
use syntax::{ast, ast_util};
use syntax::{attr, ast_map};
use syntax::opt_vec;
use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::abi::{X86, X86_64, Arm, Mips};
use syntax::abi::{RustIntrinsic, Rust, Stdcall, Fastcall,
                  Cdecl, Aapcs, C};
use middle::trans::type_::Type;

fn abi_info(ccx: @mut CrateContext) -> @cabi::ABIInfo {
    return match ccx.sess.targ_cfg.arch {
        X86 => cabi_x86::abi_info(ccx),
        X86_64 => cabi_x86_64::abi_info(),
        Arm => cabi_arm::abi_info(),
        Mips => cabi_mips::abi_info(),
    }
}

pub fn link_name(ccx: &CrateContext, i: &ast::foreign_item) -> @str {
     match attr::first_attr_value_str_by_name(i.attrs, "link_name") {
        None => ccx.sess.str_of(i.ident),
        Some(ln) => ln,
    }
}

struct ShimTypes {
    fn_sig: ty::FnSig,

    /// LLVM types that will appear on the foreign function
    llsig: LlvmSignature,

    /// True if there is a return value (not bottom, not unit)
    ret_def: bool,

    /// Type of the struct we will use to shuttle values back and forth.
    /// This is always derived from the llsig.
    bundle_ty: Type,

    /// Type of the shim function itself.
    shim_fn_ty: Type,

    /// Adapter object for handling native ABI rules (trust me, you
    /// don't want to know).
    fn_ty: cabi::FnType
}

struct LlvmSignature {
    llarg_tys: ~[Type],
    llret_ty: Type,
    sret: bool,
}

fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig)
                     -> LlvmSignature {
    /*!
     * The ForeignSignature is the LLVM types of the arguments/return type
     * of a function.  Note that these LLVM types are not quite the same
     * as the LLVM types would be for a native Rust function because foreign
     * functions just plain ignore modes.  They also don't pass aggregate
     * values by pointer like we do.
     */

    let llarg_tys = fn_sig.inputs.map(|arg_ty| type_of(ccx, *arg_ty));
    let llret_ty = type_of::type_of(ccx, fn_sig.output);
    LlvmSignature {
        llarg_tys: llarg_tys,
        llret_ty: llret_ty,
        sret: !ty::type_is_immediate(ccx.tcx, fn_sig.output),
    }
}

fn shim_types(ccx: @mut CrateContext, id: ast::node_id) -> ShimTypes {
    let fn_sig = match ty::get(ty::node_id_to_type(ccx.tcx, id)).sty {
        ty::ty_bare_fn(ref fn_ty) => fn_ty.sig.clone(),
        _ => ccx.sess.bug("c_arg_and_ret_lltys called on non-function type")
    };
    let llsig = foreign_signature(ccx, &fn_sig);
    let bundle_ty = Type::struct_(llsig.llarg_tys + &[llsig.llret_ty.ptr_to()], false);
    let ret_def = !ty::type_is_bot(fn_sig.output) &&
                  !ty::type_is_nil(fn_sig.output);
    let fn_ty = abi_info(ccx).compute_info(llsig.llarg_tys, llsig.llret_ty, ret_def);
    ShimTypes {
        fn_sig: fn_sig,
        llsig: llsig,
        ret_def: ret_def,
        bundle_ty: bundle_ty,
        shim_fn_ty: Type::func([bundle_ty.ptr_to()], &Type::void()),
        fn_ty: fn_ty
    }
}

type shim_arg_builder<'self> =
    &'self fn(bcx: @mut Block, tys: &ShimTypes,
              llargbundle: ValueRef) -> ~[ValueRef];

type shim_ret_builder<'self> =
    &'self fn(bcx: @mut Block, tys: &ShimTypes,
              llargbundle: ValueRef,
              llretval: ValueRef);

fn build_shim_fn_(ccx: @mut CrateContext,
                  shim_name: &str,
                  llbasefn: ValueRef,
                  tys: &ShimTypes,
                  cc: lib::llvm::CallConv,
                  arg_builder: shim_arg_builder,
                  ret_builder: shim_ret_builder)
               -> ValueRef {
    let llshimfn = decl_internal_cdecl_fn(
        ccx.llmod, shim_name, tys.shim_fn_ty);

    // Declare the body of the shim function:
    let fcx = new_fn_ctxt(ccx, ~[], llshimfn, tys.fn_sig.output, None);
    let bcx = fcx.entry_bcx.get();

    let llargbundle = get_param(llshimfn, 0u);
    let llargvals = arg_builder(bcx, tys, llargbundle);

    // Create the call itself and store the return value:
    let llretval = CallWithConv(bcx, llbasefn, llargvals, cc);

    ret_builder(bcx, tys, llargbundle, llretval);

    // Don't finish up the function in the usual way, because this doesn't
    // follow the normal Rust calling conventions.
    let ret_cx = match fcx.llreturn {
        Some(llreturn) => raw_block(fcx, false, llreturn),
        None => bcx
    };
    RetVoid(ret_cx);
    fcx.cleanup();

    return llshimfn;
}

type wrap_arg_builder<'self> = &'self fn(bcx: @mut Block,
                                         tys: &ShimTypes,
                                         llwrapfn: ValueRef,
                                         llargbundle: ValueRef);

type wrap_ret_builder<'self> = &'self fn(bcx: @mut Block,
                                         tys: &ShimTypes,
                                         llargbundle: ValueRef);

fn build_wrap_fn_(ccx: @mut CrateContext,
                  tys: &ShimTypes,
                  llshimfn: ValueRef,
                  llwrapfn: ValueRef,
                  shim_upcall: ValueRef,
                  needs_c_return: bool,
                  arg_builder: wrap_arg_builder,
                  ret_builder: wrap_ret_builder) {
    let _icx = push_ctxt("foreign::build_wrap_fn_");
    let fcx = new_fn_ctxt(ccx, ~[], llwrapfn, tys.fn_sig.output, None);
    let bcx = fcx.entry_bcx.get();

    // Patch up the return type if it's not immediate and we're returning via
    // the C ABI.
    if needs_c_return && !ty::type_is_immediate(ccx.tcx, tys.fn_sig.output) {
        let lloutputtype = type_of::type_of(fcx.ccx, tys.fn_sig.output);
        fcx.llretptr = Some(alloca(bcx, lloutputtype, ""));
    }

    // Allocate the struct and write the arguments into it.
    let llargbundle = alloca(bcx, tys.bundle_ty, "__llargbundle");
    arg_builder(bcx, tys, llwrapfn, llargbundle);

    // Create call itself.
    let llshimfnptr = PointerCast(bcx, llshimfn, Type::i8p());
    let llrawargbundle = PointerCast(bcx, llargbundle, Type::i8p());
    Call(bcx, shim_upcall, [llrawargbundle, llshimfnptr]);
    ret_builder(bcx, tys, llargbundle);

    // Then return according to the C ABI.
    let return_context = match fcx.llreturn {
        Some(llreturn) => raw_block(fcx, false, llreturn),
        None => bcx
    };

    let llfunctiontype = val_ty(llwrapfn);
    let llfunctiontype = llfunctiontype.element_type();
    let return_type = llfunctiontype.return_type();
    if return_type.kind() == ::lib::llvm::Void {
        // XXX: This might be wrong if there are any functions for which
        // the C ABI specifies a void output pointer and the Rust ABI
        // does not.
        RetVoid(return_context);
    } else {
        // Cast if we have to...
        // XXX: This is ugly.
        let llretptr = BitCast(return_context, fcx.llretptr.get(), return_type.ptr_to());
        Ret(return_context, Load(return_context, llretptr));
    }
    fcx.cleanup();
}

// For each foreign function F, we generate a wrapper function W and a shim
// function S that all work together.  The wrapper function W is the function
// that other rust code actually invokes.  Its job is to marshall the
// arguments into a struct.  It then uses a small bit of assembly to switch
// over to the C stack and invoke the shim function.  The shim function S then
// unpacks the arguments from the struct and invokes the actual function F
// according to its specified calling convention.
//
// Example: Given a foreign c-stack function F(x: X, y: Y) -> Z,
// we generate a wrapper function W that looks like:
//
//    void W(Z* dest, void *env, X x, Y y) {
//        struct { X x; Y y; Z *z; } args = { x, y, z };
//        call_on_c_stack_shim(S, &args);
//    }
//
// The shim function S then looks something like:
//
//     void S(struct { X x; Y y; Z *z; } *args) {
//         *args->z = F(args->x, args->y);
//     }
//
// However, if the return type of F is dynamically sized or of aggregate type,
// the shim function looks like:
//
//     void S(struct { X x; Y y; Z *z; } *args) {
//         F(args->z, args->x, args->y);
//     }
//
// Note: on i386, the layout of the args struct is generally the same
// as the desired layout of the arguments on the C stack.  Therefore,
// we could use upcall_alloc_c_stack() to allocate the `args`
// structure and switch the stack pointer appropriately to avoid a
// round of copies.  (In fact, the shim function itself is
// unnecessary). We used to do this, in fact, and will perhaps do so
// in the future.
pub fn trans_foreign_mod(ccx: @mut CrateContext,
                         path: &ast_map::path,
                         foreign_mod: &ast::foreign_mod) {
    let _icx = push_ctxt("foreign::trans_foreign_mod");

    let arch = ccx.sess.targ_cfg.arch;
    let abi = match foreign_mod.abis.for_arch(arch) {
        None => {
            ccx.sess.fatal(
                fmt!("No suitable ABI for target architecture \
                      in module %s",
                     ast_map::path_to_str(*path,
                                          ccx.sess.intr())));
        }

        Some(abi) => abi,
    };

    for foreign_mod.items.iter().advance |&foreign_item| {
        match foreign_item.node {
            ast::foreign_item_fn(*) => {
                let id = foreign_item.id;
                match abi {
                    RustIntrinsic => {
                        // Intrinsics are emitted by monomorphic fn
                    }

                    Rust => {
                        // FIXME(#3678) Implement linking to foreign fns with Rust ABI
                        ccx.sess.unimpl(
                            fmt!("Foreign functions with Rust ABI"));
                    }

                    Stdcall => {
                        build_foreign_fn(ccx, id, foreign_item,
                                         lib::llvm::X86StdcallCallConv);
                    }

                    Fastcall => {
                        build_foreign_fn(ccx, id, foreign_item,
                                         lib::llvm::X86FastcallCallConv);
                    }

                    Cdecl => {
                        // FIXME(#3678) should really be more specific
                        build_foreign_fn(ccx, id, foreign_item,
                                         lib::llvm::CCallConv);
                    }

                    Aapcs => {
                        // FIXME(#3678) should really be more specific
                        build_foreign_fn(ccx, id, foreign_item,
                                         lib::llvm::CCallConv);
                    }

                    C => {
                        build_foreign_fn(ccx, id, foreign_item,
                                         lib::llvm::CCallConv);
                    }
                }
            }
            ast::foreign_item_static(*) => {
                let ident = token::ident_to_str(&foreign_item.ident);
                ccx.item_symbols.insert(foreign_item.id, /* bad */ident.to_owned());
            }
        }
    }

    fn build_foreign_fn(ccx: @mut CrateContext,
                        id: ast::node_id,
                        foreign_item: @ast::foreign_item,
                        cc: lib::llvm::CallConv) {
        let llwrapfn = get_item_val(ccx, id);
        let tys = shim_types(ccx, id);
        if attr::contains_name(foreign_item.attrs, "rust_stack") {
            build_direct_fn(ccx, llwrapfn, foreign_item,
                            &tys, cc);
        } else if attr::contains_name(foreign_item.attrs, "fast_ffi") {
            build_fast_ffi_fn(ccx, llwrapfn, foreign_item, &tys, cc);
        } else {
            let llshimfn = build_shim_fn(ccx, foreign_item, &tys, cc);
            build_wrap_fn(ccx, &tys, llshimfn, llwrapfn);
        }
    }

    fn build_shim_fn(ccx: @mut CrateContext,
                     foreign_item: &ast::foreign_item,
                     tys: &ShimTypes,
                     cc: lib::llvm::CallConv)
                  -> ValueRef {
        /*!
         *
         * Build S, from comment above:
         *
         *     void S(struct { X x; Y y; Z *z; } *args) {
         *         F(args->z, args->x, args->y);
         *     }
         */

        let _icx = push_ctxt("foreign::build_shim_fn");

        fn build_args(bcx: @mut Block, tys: &ShimTypes, llargbundle: ValueRef)
                   -> ~[ValueRef] {
            let _icx = push_ctxt("foreign::shim::build_args");
            tys.fn_ty.build_shim_args(bcx, tys.llsig.llarg_tys, llargbundle)
        }

        fn build_ret(bcx: @mut Block,
                     tys: &ShimTypes,
                     llargbundle: ValueRef,
                     llretval: ValueRef) {
            let _icx = push_ctxt("foreign::shim::build_ret");
            tys.fn_ty.build_shim_ret(bcx,
                                     tys.llsig.llarg_tys,
                                     tys.ret_def,
                                     llargbundle,
                                     llretval);
        }

        let lname = link_name(ccx, foreign_item);
        let llbasefn = base_fn(ccx, lname, tys, cc);
        // Name the shim function
        let shim_name = fmt!("%s__c_stack_shim", lname);
        build_shim_fn_(ccx,
                       shim_name,
                       llbasefn,
                       tys,
                       cc,
                       build_args,
                       build_ret)
    }

    fn base_fn(ccx: &CrateContext,
               lname: &str,
               tys: &ShimTypes,
               cc: lib::llvm::CallConv)
               -> ValueRef {
        // Declare the "prototype" for the base function F:
        do tys.fn_ty.decl_fn |fnty| {
            decl_fn(ccx.llmod, lname, cc, fnty)
        }
    }

    // FIXME (#2535): this is very shaky and probably gets ABIs wrong all
    // over the place
    fn build_direct_fn(ccx: @mut CrateContext,
                       decl: ValueRef,
                       item: &ast::foreign_item,
                       tys: &ShimTypes,
                       cc: lib::llvm::CallConv) {
        debug!("build_direct_fn(%s)", link_name(ccx, item));

        let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
        let bcx = fcx.entry_bcx.get();
        let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
        let ty = ty::lookup_item_type(ccx.tcx,
                                      ast_util::local_def(item.id)).ty;
        let ret_ty = ty::ty_fn_ret(ty);
        let args = vec::from_fn(ty::ty_fn_args(ty).len(), |i| {
            get_param(decl, fcx.arg_pos(i))
        });
        let retval = Call(bcx, llbasefn, args);
        if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
            Store(bcx, retval, fcx.llretptr.get());
        }
        finish_fn(fcx, bcx);
    }

    // FIXME (#2535): this is very shaky and probably gets ABIs wrong all
    // over the place
    fn build_fast_ffi_fn(ccx: @mut CrateContext,
                         decl: ValueRef,
                         item: &ast::foreign_item,
                         tys: &ShimTypes,
                         cc: lib::llvm::CallConv) {
        debug!("build_fast_ffi_fn(%s)", link_name(ccx, item));

        let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
        let bcx = fcx.entry_bcx.get();
        let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
        set_no_inline(fcx.llfn);
        set_fixed_stack_segment(fcx.llfn);
        let ty = ty::lookup_item_type(ccx.tcx,
                                      ast_util::local_def(item.id)).ty;
        let ret_ty = ty::ty_fn_ret(ty);
        let args = vec::from_fn(ty::ty_fn_args(ty).len(), |i| {
            get_param(decl, fcx.arg_pos(i))
        });
        let retval = Call(bcx, llbasefn, args);
        if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
            Store(bcx, retval, fcx.llretptr.get());
        }
        finish_fn(fcx, bcx);
    }

    fn build_wrap_fn(ccx: @mut CrateContext,
                     tys: &ShimTypes,
                     llshimfn: ValueRef,
                     llwrapfn: ValueRef) {
        /*!
         *
         * Build W, from comment above:
         *
         *     void W(Z* dest, void *env, X x, Y y) {
         *         struct { X x; Y y; Z *z; } args = { x, y, z };
         *         call_on_c_stack_shim(S, &args);
         *     }
         *
         * One thing we have to be very careful of is to
         * account for the Rust modes.
         */

        let _icx = push_ctxt("foreign::build_wrap_fn");

        build_wrap_fn_(ccx,
                       tys,
                       llshimfn,
                       llwrapfn,
                       ccx.upcalls.call_shim_on_c_stack,
                       false,
                       build_args,
                       build_ret);

        fn build_args(bcx: @mut Block,
                      tys: &ShimTypes,
                      llwrapfn: ValueRef,
                      llargbundle: ValueRef) {
            let _icx = push_ctxt("foreign::wrap::build_args");
            let ccx = bcx.ccx();
            let n = tys.llsig.llarg_tys.len();
            for uint::range(0, n) |i| {
                let arg_i = bcx.fcx.arg_pos(i);
                let mut llargval = get_param(llwrapfn, arg_i);

                // In some cases, Rust will pass a pointer which the
                // native C type doesn't have.  In that case, just
                // load the value from the pointer.
                if type_of::arg_is_indirect(ccx, &tys.fn_sig.inputs[i]) {
                    llargval = Load(bcx, llargval);
                }

                store_inbounds(bcx, llargval, llargbundle, [0u, i]);
            }

            for bcx.fcx.llretptr.iter().advance |&retptr| {
                store_inbounds(bcx, retptr, llargbundle, [0u, n]);
            }
        }

        fn build_ret(bcx: @mut Block,
                     shim_types: &ShimTypes,
                     llargbundle: ValueRef) {
            let _icx = push_ctxt("foreign::wrap::build_ret");
            let arg_count = shim_types.fn_sig.inputs.len();
            for bcx.fcx.llretptr.iter().advance |&retptr| {
                let llretptr = load_inbounds(bcx, llargbundle, [0, arg_count]);
                Store(bcx, Load(bcx, llretptr), retptr);
            }
        }
    }
}

pub fn trans_intrinsic(ccx: @mut CrateContext,
                       decl: ValueRef,
                       item: &ast::foreign_item,
                       path: ast_map::path,
                       substs: @param_substs,
                       attributes: &[ast::Attribute],
                       ref_id: Option<ast::node_id>) {
    debug!("trans_intrinsic(item.ident=%s)", ccx.sess.str_of(item.ident));

    fn simple_llvm_intrinsic(bcx: @mut Block, name: &'static str, num_args: uint) {
        assert!(num_args <= 4);
        let mut args = [0 as ValueRef, ..4];
        let first_real_arg = bcx.fcx.arg_pos(0u);
        for uint::range(0, num_args) |i| {
            args[i] = get_param(bcx.fcx.llfn, first_real_arg + i);
        }
        let llfn = bcx.ccx().intrinsics.get_copy(&name);
        Ret(bcx, Call(bcx, llfn, args.slice(0, num_args)));
    }

    fn memcpy_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
        let ccx = bcx.ccx();
        let lltp_ty = type_of::type_of(ccx, tp_ty);
        let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
        let size = match sizebits {
            32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
            64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
            _ => ccx.sess.fatal("Invalid value for sizebits")
        };

        let decl = bcx.fcx.llfn;
        let first_real_arg = bcx.fcx.arg_pos(0u);
        let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p());
        let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), Type::i8p());
        let count = get_param(decl, first_real_arg + 2);
        let volatile = C_i1(false);
        let llfn = bcx.ccx().intrinsics.get_copy(&name);
        Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align, volatile]);
        RetVoid(bcx);
    }

    fn memset_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
        let ccx = bcx.ccx();
        let lltp_ty = type_of::type_of(ccx, tp_ty);
        let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
        let size = match sizebits {
            32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
            64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
            _ => ccx.sess.fatal("Invalid value for sizebits")
        };

        let decl = bcx.fcx.llfn;
        let first_real_arg = bcx.fcx.arg_pos(0u);
        let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p());
        let val = get_param(decl, first_real_arg + 1);
        let count = get_param(decl, first_real_arg + 2);
        let volatile = C_i1(false);
        let llfn = bcx.ccx().intrinsics.get_copy(&name);
        Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align, volatile]);
        RetVoid(bcx);
    }

    fn count_zeros_intrinsic(bcx: @mut Block, name: &'static str) {
        let x = get_param(bcx.fcx.llfn, bcx.fcx.arg_pos(0u));
        let y = C_i1(false);
        let llfn = bcx.ccx().intrinsics.get_copy(&name);
        Ret(bcx, Call(bcx, llfn, [x, y]));
    }

    let output_type = ty::ty_fn_ret(ty::node_id_to_type(ccx.tcx, item.id));

    let fcx = new_fn_ctxt_w_id(ccx,
                               path,
                               decl,
                               item.id,
                               output_type,
                               true,
                               Some(substs),
                               None,
                               Some(item.span));

    set_always_inline(fcx.llfn);

    // Set the fixed stack segment flag if necessary.
    if attr::contains_name(attributes, "fixed_stack_segment") {
        set_fixed_stack_segment(fcx.llfn);
    }

    let mut bcx = fcx.entry_bcx.get();
    let first_real_arg = fcx.arg_pos(0u);

    let nm = ccx.sess.str_of(item.ident);
    let name = nm.as_slice();

    // This requires that atomic intrinsics follow a specific naming pattern:
    // "atomic_<operation>[_<ordering>], and no ordering means SeqCst
    if name.starts_with("atomic_") {
        let split : ~[&str] = name.split_iter('_').collect();
        assert!(split.len() >= 2, "Atomic intrinsic not correct format");
        let order = if split.len() == 2 {
            lib::llvm::SequentiallyConsistent
        } else {
            match split[2] {
                "relaxed" => lib::llvm::Monotonic,
                "acq"     => lib::llvm::Acquire,
                "rel"     => lib::llvm::Release,
                "acqrel"  => lib::llvm::AcquireRelease,
                _ => ccx.sess.fatal("Unknown ordering in atomic intrinsic")
            }
        };

        match split[1] {
            "cxchg" => {
                let old = AtomicCmpXchg(bcx, get_param(decl, first_real_arg),
                                        get_param(decl, first_real_arg + 1u),
                                        get_param(decl, first_real_arg + 2u),
                                        order);
                Ret(bcx, old);
            }
            "load" => {
                let old = AtomicLoad(bcx, get_param(decl, first_real_arg),
                                     order);
                Ret(bcx, old);
            }
            "store" => {
                AtomicStore(bcx, get_param(decl, first_real_arg + 1u),
                            get_param(decl, first_real_arg),
                            order);
                RetVoid(bcx);
            }
            "fence" => {
                AtomicFence(bcx, order);
                RetVoid(bcx);
            }
            op => {
                // These are all AtomicRMW ops
                let atom_op = match op {
                    "xchg"  => lib::llvm::Xchg,
                    "xadd"  => lib::llvm::Add,
                    "xsub"  => lib::llvm::Sub,
                    "and"   => lib::llvm::And,
                    "nand"  => lib::llvm::Nand,
                    "or"    => lib::llvm::Or,
                    "xor"   => lib::llvm::Xor,
                    "max"   => lib::llvm::Max,
                    "min"   => lib::llvm::Min,
                    "umax"  => lib::llvm::UMax,
                    "umin"  => lib::llvm::UMin,
                    _ => ccx.sess.fatal("Unknown atomic operation")
                };

                let old = AtomicRMW(bcx, atom_op, get_param(decl, first_real_arg),
                                    get_param(decl, first_real_arg + 1u),
                                    order);
                Ret(bcx, old);
            }
        }

        fcx.cleanup();
        return;
    }

    match name {
        "size_of" => {
            let tp_ty = substs.tys[0];
            let lltp_ty = type_of::type_of(ccx, tp_ty);
            Ret(bcx, C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty)));
        }
        "move_val" => {
            // Create a datum reflecting the value being moved.
            // Use `appropriate_mode` so that the datum is by ref
            // if the value is non-immediate. Note that, with
            // intrinsics, there are no argument cleanups to
            // concern ourselves with.
            let tp_ty = substs.tys[0];
            let mode = appropriate_mode(ccx.tcx, tp_ty);
            let src = Datum {val: get_param(decl, first_real_arg + 1u),
                             ty: tp_ty, mode: mode};
            bcx = src.move_to(bcx, DROP_EXISTING,
                              get_param(decl, first_real_arg));
            RetVoid(bcx);
        }
        "move_val_init" => {
            // See comments for `"move_val"`.
            let tp_ty = substs.tys[0];
            let mode = appropriate_mode(ccx.tcx, tp_ty);
            let src = Datum {val: get_param(decl, first_real_arg + 1u),
                             ty: tp_ty, mode: mode};
            bcx = src.move_to(bcx, INIT, get_param(decl, first_real_arg));
            RetVoid(bcx);
        }
        "min_align_of" => {
            let tp_ty = substs.tys[0];
            let lltp_ty = type_of::type_of(ccx, tp_ty);
            Ret(bcx, C_uint(ccx, machine::llalign_of_min(ccx, lltp_ty)));
        }
        "pref_align_of"=> {
            let tp_ty = substs.tys[0];
            let lltp_ty = type_of::type_of(ccx, tp_ty);
            Ret(bcx, C_uint(ccx, machine::llalign_of_pref(ccx, lltp_ty)));
        }
        "get_tydesc" => {
            let tp_ty = substs.tys[0];
            let static_ti = get_tydesc(ccx, tp_ty);
            glue::lazily_emit_all_tydesc_glue(ccx, static_ti);

            // FIXME (#3730): ideally this shouldn't need a cast,
            // but there's a circularity between translating rust types to llvm
            // types and having a tydesc type available. So I can't directly access
            // the llvm type of intrinsic::TyDesc struct.
            let userland_tydesc_ty = type_of::type_of(ccx, output_type);
            let td = PointerCast(bcx, static_ti.tydesc, userland_tydesc_ty);
            Ret(bcx, td);
        }
        "init" => {
            let tp_ty = substs.tys[0];
            let lltp_ty = type_of::type_of(ccx, tp_ty);
            match bcx.fcx.llretptr {
                Some(ptr) => { Store(bcx, C_null(lltp_ty), ptr); RetVoid(bcx); }
                None if ty::type_is_nil(tp_ty) => RetVoid(bcx),
                None => Ret(bcx, C_null(lltp_ty)),
            }
        }
        "uninit" => {
            // Do nothing, this is effectively a no-op
            let retty = substs.tys[0];
            if ty::type_is_immediate(ccx.tcx, retty) && !ty::type_is_nil(retty) {
                unsafe {
                    Ret(bcx, lib::llvm::llvm::LLVMGetUndef(type_of(ccx, retty).to_ref()));
                }
            } else {
                RetVoid(bcx)
            }
        }
        "forget" => {
            RetVoid(bcx);
        }
        "transmute" => {
            let (in_type, out_type) = (substs.tys[0], substs.tys[1]);
            let llintype = type_of::type_of(ccx, in_type);
            let llouttype = type_of::type_of(ccx, out_type);

            let in_type_size = machine::llbitsize_of_real(ccx, llintype);
            let out_type_size = machine::llbitsize_of_real(ccx, llouttype);
            if in_type_size != out_type_size {
                let sp = match ccx.tcx.items.get_copy(&ref_id.get()) {
                    ast_map::node_expr(e) => e.span,
                    _ => fail!("transmute has non-expr arg"),
                };
                let pluralize = |n| if 1u == n { "" } else { "s" };
                ccx.sess.span_fatal(sp,
                                    fmt!("transmute called on types with \
                                          different sizes: %s (%u bit%s) to \
                                          %s (%u bit%s)",
                                         ty_to_str(ccx.tcx, in_type),
                                         in_type_size,
                                         pluralize(in_type_size),
                                         ty_to_str(ccx.tcx, out_type),
                                         out_type_size,
                                         pluralize(out_type_size)));
            }

            if !ty::type_is_nil(out_type) {
                let llsrcval = get_param(decl, first_real_arg);
                if ty::type_is_immediate(ccx.tcx, in_type) {
                    match fcx.llretptr {
                        Some(llretptr) => {
                            Store(bcx, llsrcval, PointerCast(bcx, llretptr, llintype.ptr_to()));
                            RetVoid(bcx);
                        }
                        None => match (llintype.kind(), llouttype.kind()) {
                            (Pointer, other) | (other, Pointer) if other != Pointer => {
                                let tmp = Alloca(bcx, llouttype, "");
                                Store(bcx, llsrcval, PointerCast(bcx, tmp, llintype.ptr_to()));
                                Ret(bcx, Load(bcx, tmp));
                            }
                            _ => Ret(bcx, BitCast(bcx, llsrcval, llouttype))
                        }
                    }
                } else if ty::type_is_immediate(ccx.tcx, out_type) {
                    let llsrcptr = PointerCast(bcx, llsrcval, llouttype.ptr_to());
                    Ret(bcx, Load(bcx, llsrcptr));
                } else {
                    // NB: Do not use a Load and Store here. This causes massive
                    // code bloat when `transmute` is used on large structural
                    // types.
                    let lldestptr = fcx.llretptr.get();
                    let lldestptr = PointerCast(bcx, lldestptr, Type::i8p());
                    let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p());

                    let llsize = llsize_of(ccx, llintype);
                    call_memcpy(bcx, lldestptr, llsrcptr, llsize, 1);
                    RetVoid(bcx);
                };
            } else {
                RetVoid(bcx);
            }
        }
        "needs_drop" => {
            let tp_ty = substs.tys[0];
            Ret(bcx, C_bool(ty::type_needs_drop(ccx.tcx, tp_ty)));
        }
        "contains_managed" => {
            let tp_ty = substs.tys[0];
            Ret(bcx, C_bool(ty::type_contents(ccx.tcx, tp_ty).contains_managed()));
        }
        "visit_tydesc" => {
            let td = get_param(decl, first_real_arg);
            let visitor = get_param(decl, first_real_arg + 1u);
            //let llvisitorptr = alloca(bcx, val_ty(visitor));
            //Store(bcx, visitor, llvisitorptr);
            let td = PointerCast(bcx, td, ccx.tydesc_type.ptr_to());
            glue::call_tydesc_glue_full(bcx, visitor, td,
                                        abi::tydesc_field_visit_glue, None);
            RetVoid(bcx);
        }
        "frame_address" => {
            let frameaddress = ccx.intrinsics.get_copy(& &"llvm.frameaddress");
            let frameaddress_val = Call(bcx, frameaddress, [C_i32(0i32)]);
            let star_u8 = ty::mk_imm_ptr(
                bcx.tcx(),
                ty::mk_mach_uint(ast::ty_u8));
            let fty = ty::mk_closure(bcx.tcx(), ty::ClosureTy {
                purity: ast::impure_fn,
                sigil: ast::BorrowedSigil,
                onceness: ast::Many,
                region: ty::re_bound(ty::br_anon(0)),
                bounds: ty::EmptyBuiltinBounds(),
                sig: FnSig {
                    bound_lifetime_names: opt_vec::Empty,
                    inputs: ~[ star_u8 ],
                    output: ty::mk_nil()
                }
            });
            let datum = Datum {val: get_param(decl, first_real_arg),
                               mode: ByRef(ZeroMem), ty: fty};
            let arg_vals = ~[frameaddress_val];
            bcx = trans_call_inner(
                bcx, None, fty, ty::mk_nil(),
                |bcx| Callee {bcx: bcx, data: Closure(datum)},
                ArgVals(arg_vals), Some(Ignore), DontAutorefArg).bcx;
            RetVoid(bcx);
        }
        "morestack_addr" => {
            // XXX This is a hack to grab the address of this particular
            // native function. There should be a general in-language
            // way to do this
            let llfty = type_of_fn(bcx.ccx(), [], ty::mk_nil());
            let morestack_addr = decl_cdecl_fn(
                bcx.ccx().llmod, "__morestack", llfty);
            let morestack_addr = PointerCast(bcx, morestack_addr, Type::nil().ptr_to());
            Ret(bcx, morestack_addr);
        }
        "memcpy32" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i32", substs.tys[0], 32),
        "memcpy64" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i64", substs.tys[0], 64),
        "memmove32" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i32", substs.tys[0], 32),
        "memmove64" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i64", substs.tys[0], 64),
        "memset32" => memset_intrinsic(bcx, "llvm.memset.p0i8.i32", substs.tys[0], 32),
        "memset64" => memset_intrinsic(bcx, "llvm.memset.p0i8.i64", substs.tys[0], 64),
        "sqrtf32" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f32", 1),
        "sqrtf64" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f64", 1),
        "powif32" => simple_llvm_intrinsic(bcx, "llvm.powi.f32", 2),
        "powif64" => simple_llvm_intrinsic(bcx, "llvm.powi.f64", 2),
        "sinf32" => simple_llvm_intrinsic(bcx, "llvm.sin.f32", 1),
        "sinf64" => simple_llvm_intrinsic(bcx, "llvm.sin.f64", 1),
        "cosf32" => simple_llvm_intrinsic(bcx, "llvm.cos.f32", 1),
        "cosf64" => simple_llvm_intrinsic(bcx, "llvm.cos.f64", 1),
        "powf32" => simple_llvm_intrinsic(bcx, "llvm.pow.f32", 2),
        "powf64" => simple_llvm_intrinsic(bcx, "llvm.pow.f64", 2),
        "expf32" => simple_llvm_intrinsic(bcx, "llvm.exp.f32", 1),
        "expf64" => simple_llvm_intrinsic(bcx, "llvm.exp.f64", 1),
        "exp2f32" => simple_llvm_intrinsic(bcx, "llvm.exp2.f32", 1),
        "exp2f64" => simple_llvm_intrinsic(bcx, "llvm.exp2.f64", 1),
        "logf32" => simple_llvm_intrinsic(bcx, "llvm.log.f32", 1),
        "logf64" => simple_llvm_intrinsic(bcx, "llvm.log.f64", 1),
        "log10f32" => simple_llvm_intrinsic(bcx, "llvm.log10.f32", 1),
        "log10f64" => simple_llvm_intrinsic(bcx, "llvm.log10.f64", 1),
        "log2f32" => simple_llvm_intrinsic(bcx, "llvm.log2.f32", 1),
        "log2f64" => simple_llvm_intrinsic(bcx, "llvm.log2.f64", 1),
        "fmaf32" => simple_llvm_intrinsic(bcx, "llvm.fma.f32", 3),
        "fmaf64" => simple_llvm_intrinsic(bcx, "llvm.fma.f64", 3),
        "fabsf32" => simple_llvm_intrinsic(bcx, "llvm.fabs.f32", 1),
        "fabsf64" => simple_llvm_intrinsic(bcx, "llvm.fabs.f64", 1),
        "floorf32" => simple_llvm_intrinsic(bcx, "llvm.floor.f32", 1),
        "floorf64" => simple_llvm_intrinsic(bcx, "llvm.floor.f64", 1),
        "ceilf32" => simple_llvm_intrinsic(bcx, "llvm.ceil.f32", 1),
        "ceilf64" => simple_llvm_intrinsic(bcx, "llvm.ceil.f64", 1),
        "truncf32" => simple_llvm_intrinsic(bcx, "llvm.trunc.f32", 1),
        "truncf64" => simple_llvm_intrinsic(bcx, "llvm.trunc.f64", 1),
        "ctpop8" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i8", 1),
        "ctpop16" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i16", 1),
        "ctpop32" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i32", 1),
        "ctpop64" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i64", 1),
        "ctlz8" => count_zeros_intrinsic(bcx, "llvm.ctlz.i8"),
        "ctlz16" => count_zeros_intrinsic(bcx, "llvm.ctlz.i16"),
        "ctlz32" => count_zeros_intrinsic(bcx, "llvm.ctlz.i32"),
        "ctlz64" => count_zeros_intrinsic(bcx, "llvm.ctlz.i64"),
        "cttz8" => count_zeros_intrinsic(bcx, "llvm.cttz.i8"),
        "cttz16" => count_zeros_intrinsic(bcx, "llvm.cttz.i16"),
        "cttz32" => count_zeros_intrinsic(bcx, "llvm.cttz.i32"),
        "cttz64" => count_zeros_intrinsic(bcx, "llvm.cttz.i64"),
        "bswap16" => simple_llvm_intrinsic(bcx, "llvm.bswap.i16", 1),
        "bswap32" => simple_llvm_intrinsic(bcx, "llvm.bswap.i32", 1),
        "bswap64" => simple_llvm_intrinsic(bcx, "llvm.bswap.i64", 1),
        _ => {
            // Could we make this an enum rather than a string? does it get
            // checked earlier?
            ccx.sess.span_bug(item.span, "unknown intrinsic");
        }
    }
    fcx.cleanup();
}

/**
 * Translates a "crust" fn, meaning a Rust fn that can be called
 * from C code.  In this case, we have to perform some adaptation
 * to (1) switch back to the Rust stack and (2) adapt the C calling
 * convention to our own.
 *
 * Example: Given a crust fn F(x: X, y: Y) -> Z, we generate a
 * Rust function R as normal:
 *
 *    void R(Z* dest, void *env, X x, Y y) {...}
 *
 * and then we generate a wrapper function W that looks like:
 *
 *    Z W(X x, Y y) {
 *        struct { X x; Y y; Z *z; } args = { x, y, z };
 *        call_on_c_stack_shim(S, &args);
 *    }
 *
 * Note that the wrapper follows the foreign (typically "C") ABI.
 * The wrapper is the actual "value" of the foreign fn.  Finally,
 * we generate a shim function S that looks like:
 *
 *     void S(struct { X x; Y y; Z *z; } *args) {
 *         R(args->z, NULL, args->x, args->y);
 *     }
 */
pub fn trans_foreign_fn(ccx: @mut CrateContext,
                        path: ast_map::path,
                        decl: &ast::fn_decl,
                        body: &ast::Block,
                        llwrapfn: ValueRef,
                        id: ast::node_id) {
    let _icx = push_ctxt("foreign::build_foreign_fn");

    fn build_rust_fn(ccx: @mut CrateContext,
                     path: &ast_map::path,
                     decl: &ast::fn_decl,
                     body: &ast::Block,
                     id: ast::node_id)
                  -> ValueRef {
        let _icx = push_ctxt("foreign::foreign::build_rust_fn");
        let t = ty::node_id_to_type(ccx.tcx, id);
        // XXX: Bad copy.
        let ps = link::mangle_internal_name_by_path(
                            ccx,
                            vec::append_one((*path).clone(),
                                            ast_map::path_name(
                                            special_idents::clownshoe_abi)));
        let llty = type_of_fn_from_ty(ccx, t);
        let llfndecl = decl_internal_cdecl_fn(ccx.llmod, ps, llty);
        trans_fn(ccx,
                 (*path).clone(),
                 decl,
                 body,
                 llfndecl,
                 no_self,
                 None,
                 id,
                 []);
        return llfndecl;
    }

    fn build_shim_fn(ccx: @mut CrateContext,
                     path: ast_map::path,
                     llrustfn: ValueRef,
                     tys: &ShimTypes)
                     -> ValueRef {
        /*!
         *
         * Generate the shim S:
         *
         *     void S(struct { X x; Y y; Z *z; } *args) {
         *         R(args->z, NULL, &args->x, args->y);
         *     }
         *
         * One complication is that we must adapt to the Rust
         * calling convention, which introduces indirection
         * in some cases.  To demonstrate this, I wrote one of the
         * entries above as `&args->x`, because presumably `X` is
         * one of those types that is passed by pointer in Rust.
         */

        let _icx = push_ctxt("foreign::foreign::build_shim_fn");

        fn build_args(bcx: @mut Block, tys: &ShimTypes, llargbundle: ValueRef)
                      -> ~[ValueRef] {
            let _icx = push_ctxt("foreign::extern::shim::build_args");
            let ccx = bcx.ccx();
            let mut llargvals = ~[];
            let mut i = 0u;
            let n = tys.fn_sig.inputs.len();

            if !ty::type_is_immediate(bcx.tcx(), tys.fn_sig.output) {
                let llretptr = load_inbounds(bcx, llargbundle, [0u, n]);
                llargvals.push(llretptr);
            }

            let llenvptr = C_null(Type::opaque_box(bcx.ccx()).ptr_to());
            llargvals.push(llenvptr);
            while i < n {
                // Get a pointer to the argument:
                let mut llargval = GEPi(bcx, llargbundle, [0u, i]);

                if !type_of::arg_is_indirect(ccx, &tys.fn_sig.inputs[i]) {
                    // If Rust would pass this by value, load the value.
                    llargval = Load(bcx, llargval);
                }

                llargvals.push(llargval);
                i += 1u;
            }
            return llargvals;
        }

        fn build_ret(bcx: @mut Block,
                     shim_types: &ShimTypes,
                     llargbundle: ValueRef,
                     llretval: ValueRef) {
            if bcx.fcx.llretptr.is_some() &&
                ty::type_is_immediate(bcx.tcx(), shim_types.fn_sig.output) {
                // Write the value into the argument bundle.
                let arg_count = shim_types.fn_sig.inputs.len();
                let llretptr = load_inbounds(bcx,
                                             llargbundle,
                                             [0, arg_count]);
                Store(bcx, llretval, llretptr);
            } else {
                // NB: The return pointer in the Rust ABI function is wired
                // directly into the return slot in the shim struct.
            }
        }

        let shim_name = link::mangle_internal_name_by_path(
            ccx,
            vec::append_one(path, ast_map::path_name(
                special_idents::clownshoe_stack_shim
            )));
        build_shim_fn_(ccx,
                       shim_name,
                       llrustfn,
                       tys,
                       lib::llvm::CCallConv,
                       build_args,
                       build_ret)
    }

    fn build_wrap_fn(ccx: @mut CrateContext,
                     llshimfn: ValueRef,
                     llwrapfn: ValueRef,
                     tys: &ShimTypes) {
        /*!
         *
         * Generate the wrapper W:
         *
         *    Z W(X x, Y y) {
         *        struct { X x; Y y; Z *z; } args = { x, y, z };
         *        call_on_c_stack_shim(S, &args);
         *    }
         */

        let _icx = push_ctxt("foreign::foreign::build_wrap_fn");

        build_wrap_fn_(ccx,
                       tys,
                       llshimfn,
                       llwrapfn,
                       ccx.upcalls.call_shim_on_rust_stack,
                       true,
                       build_args,
                       build_ret);

        fn build_args(bcx: @mut Block,
                      tys: &ShimTypes,
                      llwrapfn: ValueRef,
                      llargbundle: ValueRef) {
            let _icx = push_ctxt("foreign::foreign::wrap::build_args");
            tys.fn_ty.build_wrap_args(bcx,
                                      tys.llsig.llret_ty,
                                      llwrapfn,
                                      llargbundle);
        }

        fn build_ret(bcx: @mut Block, tys: &ShimTypes, llargbundle: ValueRef) {
            let _icx = push_ctxt("foreign::foreign::wrap::build_ret");
            tys.fn_ty.build_wrap_ret(bcx, tys.llsig.llarg_tys, llargbundle);
        }
    }

    let tys = shim_types(ccx, id);
    // The internal Rust ABI function - runs on the Rust stack
    // XXX: Bad copy.
    let llrustfn = build_rust_fn(ccx, &path, decl, body, id);
    // The internal shim function - runs on the Rust stack
    let llshimfn = build_shim_fn(ccx, path, llrustfn, &tys);
    // The foreign C function - runs on the C stack
    build_wrap_fn(ccx, llshimfn, llwrapfn, &tys)
}

pub fn register_foreign_fn(ccx: @mut CrateContext,
                           sp: span,
                           sym: ~str,
                           node_id: ast::node_id)
                           -> ValueRef {
    let _icx = push_ctxt("foreign::register_foreign_fn");

    let t = ty::node_id_to_type(ccx.tcx, node_id);
    let sym = Cell::new(sym);

    let tys = shim_types(ccx, node_id);
    do tys.fn_ty.decl_fn |fnty| {
        register_fn_fuller(ccx,
                           sp,
                           sym.take(),
                           node_id,
                           t,
                           lib::llvm::CCallConv,
                           fnty)
    }
}