---

yaml
---
r: 146428
b: refs/heads/try2
c: 379bda9
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 4b9c5d6878522a23d97db14ff85b6bdc6e2edd84
+refs/heads/try2: 379bda9e527809fcf149383ac52c4afd1328c649
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/lib/llvm.rs

@@ -29,6 +29,7 @@ pub static False: Bool = 0 as Bool;
 
 // Consts for the LLVM CallConv type, pre-cast to uint.
 
+#[deriving(Eq)]
 pub enum CallConv {
     CCallConv = 0,
     FastCallConv = 8,

branches/try2/src/librustc/metadata/tydecode.rs

@@ -526,10 +526,17 @@ fn parse_sig(st: &mut PState, conv: conv_did) -> ty::FnSig {
         inputs.push(parse_ty(st, |x,y| conv(x,y)));
     }
     st.pos += 1u; // eat the ']'
+    let variadic = if peek(st) == 'A' {
+        st.pos += 1; // eat the 'A'
+        true
+    } else { false };
     let ret_ty = parse_ty(st, conv);
-    ty::FnSig {bound_lifetime_names: opt_vec::Empty, // FIXME(#4846)
-               inputs: inputs,
-               output: ret_ty}
+    ty::FnSig {
+        bound_lifetime_names: opt_vec::Empty, // FIXME(#4846)
+        inputs: inputs,
+        output: ret_ty,
+        variadic: variadic
+    }
 }
 
 // Rust metadata parsing

branches/try2/src/librustc/metadata/tyencode.rs

@@ -371,6 +371,9 @@ fn enc_fn_sig(w: @mut MemWriter, cx: @ctxt, fsig: &ty::FnSig) {
         enc_ty(w, cx, *ty);
     }
     mywrite!(w, "]");
+    if fsig.variadic {
+        mywrite!(w, "A");
+    }
     enc_ty(w, cx, fsig.output);
 }
 

branches/try2/src/librustc/middle/trans/callee.rs

@@ -750,8 +750,12 @@ pub fn trans_call_inner(in_cx: @mut Block,
             let mut llargs = ~[];
             bcx = trans_args(bcx, args, callee_ty,
                              autoref_arg, &mut llargs);
+            let arg_tys = match args {
+                ArgExprs(a) => a.iter().map(|x| expr_ty(bcx, *x)).collect(),
+                ArgVals(_) => fail!("expected arg exprs.")
+            };
             bcx = foreign::trans_native_call(bcx, callee_ty,
-                                             llfn, opt_llretslot.unwrap(), llargs);
+                                             llfn, opt_llretslot.unwrap(), llargs, arg_tys);
         }
 
         // If the caller doesn't care about the result of this fn call,
@@ -789,6 +793,7 @@ pub fn trans_args(cx: @mut Block,
     let _icx = push_ctxt("trans_args");
     let mut temp_cleanups = ~[];
     let arg_tys = ty::ty_fn_args(fn_ty);
+    let variadic = ty::fn_is_variadic(fn_ty);
 
     let mut bcx = cx;
 
@@ -797,10 +802,17 @@ pub fn trans_args(cx: @mut Block,
     // to cast her view of the arguments to the caller's view.
     match args {
       ArgExprs(arg_exprs) => {
+        let num_formal_args = arg_tys.len();
         for (i, arg_expr) in arg_exprs.iter().enumerate() {
+            let arg_ty = if i >= num_formal_args {
+                assert!(variadic);
+                expr_ty_adjusted(cx, *arg_expr)
+            } else {
+                arg_tys[i]
+            };
             let arg_val = unpack_result!(bcx, {
                 trans_arg_expr(bcx,
-                               arg_tys[i],
+                               arg_ty,
                                ty::ByCopy,
                                *arg_expr,
                                &mut temp_cleanups,

branches/try2/src/librustc/middle/trans/foreign.rs

@@ -120,8 +120,7 @@ pub fn register_foreign_item_fn(ccx: @mut CrateContext,
     let cc = match llvm_calling_convention(ccx, abis) {
         Some(cc) => cc,
         None => {
-            // FIXME(#8357) We really ought to report a span here
-            ccx.sess.fatal(
+            ccx.sess.span_fatal(foreign_item.span,
                 format!("ABI `{}` has no suitable ABI \
                       for target architecture \
                       in module {}",
@@ -135,6 +134,12 @@ pub fn register_foreign_item_fn(ccx: @mut CrateContext,
     let lname = link_name(ccx, foreign_item);
     let tys = foreign_types_for_id(ccx, foreign_item.id);
 
+    // Make sure the calling convention is right for variadic functions
+    // (should've been caught if not in typeck)
+    if tys.fn_sig.variadic {
+        assert!(cc == lib::llvm::CCallConv);
+    }
+
     // Create the LLVM value for the C extern fn
     let llfn_ty = lltype_for_fn_from_foreign_types(&tys);
     let llfn = base::get_extern_fn(&mut ccx.externs, ccx.llmod,
@@ -148,7 +153,8 @@ pub fn trans_native_call(bcx: @mut Block,
                          callee_ty: ty::t,
                          llfn: ValueRef,
                          llretptr: ValueRef,
-                         llargs_rust: &[ValueRef]) -> @mut Block {
+                         llargs_rust: &[ValueRef],
+                         passed_arg_tys: ~[ty::t]) -> @mut Block {
     /*!
      * Prepares a call to a native function. This requires adapting
      * from the Rust argument passing rules to the native rules.
@@ -160,6 +166,10 @@ pub fn trans_native_call(bcx: @mut Block,
      * - `llretptr`: where to store the return value of the function
      * - `llargs_rust`: a list of the argument values, prepared
      *   as they would be if calling a Rust function
+     * - `passed_arg_tys`: Rust type for the arguments. Normally we
+     *   can derive these from callee_ty but in the case of variadic
+     *   functions passed_arg_tys will include the Rust type of all
+     *   the arguments including the ones not specified in the fn's signature.
      */
 
     let ccx = bcx.ccx();
@@ -176,7 +186,7 @@ pub fn trans_native_call(bcx: @mut Block,
         ty::ty_bare_fn(ref fn_ty) => (fn_ty.abis, fn_ty.sig.clone()),
         _ => ccx.sess.bug("trans_native_call called on non-function type")
     };
-    let llsig = foreign_signature(ccx, &fn_sig);
+    let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys);
     let ret_def = !ty::type_is_voidish(bcx.tcx(), fn_sig.output);
     let fn_type = cabi::compute_abi_info(ccx,
                                          llsig.llarg_tys,
@@ -208,7 +218,7 @@ pub fn trans_native_call(bcx: @mut Block,
         let mut llarg_rust = llarg_rust;
 
         // Does Rust pass this argument by pointer?
-        let rust_indirect = type_of::arg_is_indirect(ccx, fn_sig.inputs[i]);
+        let rust_indirect = type_of::arg_is_indirect(ccx, passed_arg_tys[i]);
 
         debug!("argument {}, llarg_rust={}, rust_indirect={}, arg_ty={}",
                i,
@@ -219,7 +229,7 @@ pub fn trans_native_call(bcx: @mut Block,
         // Ensure that we always have the Rust value indirectly,
         // because it makes bitcasting easier.
         if !rust_indirect {
-            let scratch = base::alloca(bcx, type_of::type_of(ccx, fn_sig.inputs[i]), "__arg");
+            let scratch = base::alloca(bcx, type_of::type_of(ccx, passed_arg_tys[i]), "__arg");
             Store(bcx, llarg_rust, scratch);
             llarg_rust = scratch;
         }
@@ -331,6 +341,20 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
                          foreign_mod: &ast::foreign_mod) {
     let _icx = push_ctxt("foreign::trans_foreign_mod");
     for &foreign_item in foreign_mod.items.iter() {
+        match foreign_item.node {
+            ast::foreign_item_fn(*) => {
+                let (abis, mut path) = match ccx.tcx.items.get_copy(&foreign_item.id) {
+                    ast_map::node_foreign_item(_, abis, _, path) => (abis, (*path).clone()),
+                    _ => fail!("Unable to find foreign item in tcx.items table.")
+                };
+                if !(abis.is_rust() || abis.is_intrinsic()) {
+                    path.push(ast_map::path_name(foreign_item.ident));
+                    register_foreign_item_fn(ccx, abis, &path, foreign_item);
+                }
+            }
+            _ => ()
+        }
+
         let lname = link_name(ccx, foreign_item);
         ccx.item_symbols.insert(foreign_item.id, lname.to_owned());
     }
@@ -701,7 +725,7 @@ pub fn link_name(ccx: &CrateContext, i: @ast::foreign_item) -> @str {
     }
 }
 
-fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig)
+fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig, arg_tys: &[ty::t])
                      -> LlvmSignature {
     /*!
      * The ForeignSignature is the LLVM types of the arguments/return type
@@ -711,7 +735,7 @@ fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig)
      * values by pointer like we do.
      */
 
-    let llarg_tys = fn_sig.inputs.map(|&arg| type_of(ccx, arg));
+    let llarg_tys = arg_tys.map(|&arg| type_of(ccx, arg));
     let llret_ty = type_of::type_of(ccx, fn_sig.output);
     LlvmSignature {
         llarg_tys: llarg_tys,
@@ -731,7 +755,7 @@ fn foreign_types_for_fn_ty(ccx: &mut CrateContext,
         ty::ty_bare_fn(ref fn_ty) => fn_ty.sig.clone(),
         _ => ccx.sess.bug("foreign_types_for_fn_ty called on non-function type")
     };
-    let llsig = foreign_signature(ccx, &fn_sig);
+    let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs);
     let ret_def = !ty::type_is_voidish(ccx.tcx, fn_sig.output);
     let fn_ty = cabi::compute_abi_info(ccx,
                                        llsig.llarg_tys,
@@ -790,7 +814,11 @@ fn lltype_for_fn_from_foreign_types(tys: &ForeignTypes) -> Type {
         llargument_tys.push(llarg_ty);
     }
 
-    Type::func(llargument_tys, &llreturn_ty)
+    if tys.fn_sig.variadic {
+        Type::variadic_func(llargument_tys, &llreturn_ty)
+    } else {
+        Type::func(llargument_tys, &llreturn_ty)
+    }
 }
 
 pub fn lltype_for_foreign_fn(ccx: &mut CrateContext, ty: ty::t) -> Type {

branches/try2/src/librustc/middle/trans/intrinsic.rs

@@ -285,6 +285,11 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             let td = PointerCast(bcx, static_ti.tydesc, userland_tydesc_ty);
             Ret(bcx, td);
         }
+        "type_id" => {
+            let hash = ty::hash_crate_independent(ccx.tcx, substs.tys[0],
+                                                  ccx.link_meta.extras_hash);
+            Ret(bcx, C_i64(hash as i64))
+        }
         "init" => {
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);

branches/try2/src/librustc/middle/trans/reflect.rs

@@ -375,6 +375,7 @@ impl Reflector {
             self.visit("fn_input", extra);
         }
         let extra = ~[self.c_uint(retval),
+                      self.c_bool(sig.variadic),
                       self.c_tydesc(sig.output)];
         self.visit("fn_output", extra);
     }

branches/try2/src/librustc/middle/trans/type_.rs

@@ -154,6 +154,12 @@ impl Type {
                                    args.len() as c_uint, False))
     }
 
+    pub fn variadic_func(args: &[Type], ret: &Type) -> Type {
+        let vec : &[TypeRef] = unsafe { cast::transmute(args) };
+        ty!(llvm::LLVMFunctionType(ret.to_ref(), vec::raw::to_ptr(vec),
+                                   args.len() as c_uint, True))
+    }
+
     pub fn func_pair(cx: &CrateContext, fn_ty: &Type) -> Type {
         Type::struct_([fn_ty.ptr_to(), Type::opaque_cbox_ptr(cx)], false)
     }