---

yaml
---
r: 146429
b: refs/heads/try2
c: 6184e84
h: refs/heads/master
i:
  146427: 0fc1cee
v: v3

Author: sfackler

[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: 379bda9e527809fcf149383ac52c4afd1328c649
+refs/heads/try2: 6184e844fbf42f980dfc3ab0d1b7f983251963a2
 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,7 +29,6 @@ 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,17 +526,10 @@ 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,
-        variadic: variadic
-    }
+    ty::FnSig {bound_lifetime_names: opt_vec::Empty, // FIXME(#4846)
+               inputs: inputs,
+               output: ret_ty}
 }
 
 // Rust metadata parsing

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

@@ -371,9 +371,6 @@ 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,12 +750,8 @@ 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, arg_tys);
+                                             llfn, opt_llretslot.unwrap(), llargs);
         }
 
         // If the caller doesn't care about the result of this fn call,
@@ -793,7 +789,6 @@ 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;
 
@@ -802,17 +797,10 @@ 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_ty,
+                               arg_tys[i],
                                ty::ByCopy,
                                *arg_expr,
                                &mut temp_cleanups,

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

@@ -120,7 +120,8 @@ pub fn register_foreign_item_fn(ccx: @mut CrateContext,
     let cc = match llvm_calling_convention(ccx, abis) {
         Some(cc) => cc,
         None => {
-            ccx.sess.span_fatal(foreign_item.span,
+            // FIXME(#8357) We really ought to report a span here
+            ccx.sess.fatal(
                 format!("ABI `{}` has no suitable ABI \
                       for target architecture \
                       in module {}",
@@ -134,12 +135,6 @@ 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,
@@ -153,8 +148,7 @@ pub fn trans_native_call(bcx: @mut Block,
                          callee_ty: ty::t,
                          llfn: ValueRef,
                          llretptr: ValueRef,
-                         llargs_rust: &[ValueRef],
-                         passed_arg_tys: ~[ty::t]) -> @mut Block {
+                         llargs_rust: &[ValueRef]) -> @mut Block {
     /*!
      * Prepares a call to a native function. This requires adapting
      * from the Rust argument passing rules to the native rules.
@@ -166,10 +160,6 @@ 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();
@@ -186,7 +176,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, passed_arg_tys);
+    let llsig = foreign_signature(ccx, &fn_sig);
     let ret_def = !ty::type_is_voidish(bcx.tcx(), fn_sig.output);
     let fn_type = cabi::compute_abi_info(ccx,
                                          llsig.llarg_tys,
@@ -218,7 +208,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, passed_arg_tys[i]);
+        let rust_indirect = type_of::arg_is_indirect(ccx, fn_sig.inputs[i]);
 
         debug!("argument {}, llarg_rust={}, rust_indirect={}, arg_ty={}",
                i,
@@ -229,7 +219,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, passed_arg_tys[i]), "__arg");
+            let scratch = base::alloca(bcx, type_of::type_of(ccx, fn_sig.inputs[i]), "__arg");
             Store(bcx, llarg_rust, scratch);
             llarg_rust = scratch;
         }
@@ -341,20 +331,6 @@ 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());
     }
@@ -725,7 +701,7 @@ pub fn link_name(ccx: &CrateContext, i: @ast::foreign_item) -> @str {
     }
 }
 
-fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig, arg_tys: &[ty::t])
+fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig)
                      -> LlvmSignature {
     /*!
      * The ForeignSignature is the LLVM types of the arguments/return type
@@ -735,7 +711,7 @@ fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig, arg_tys: &[ty::
      * values by pointer like we do.
      */
 
-    let llarg_tys = arg_tys.map(|&arg| type_of(ccx, arg));
+    let llarg_tys = fn_sig.inputs.map(|&arg| type_of(ccx, arg));
     let llret_ty = type_of::type_of(ccx, fn_sig.output);
     LlvmSignature {
         llarg_tys: llarg_tys,
@@ -755,7 +731,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, fn_sig.inputs);
+    let llsig = foreign_signature(ccx, &fn_sig);
     let ret_def = !ty::type_is_voidish(ccx.tcx, fn_sig.output);
     let fn_ty = cabi::compute_abi_info(ccx,
                                        llsig.llarg_tys,
@@ -814,11 +790,7 @@ fn lltype_for_fn_from_foreign_types(tys: &ForeignTypes) -> Type {
         llargument_tys.push(llarg_ty);
     }
 
-    if tys.fn_sig.variadic {
-        Type::variadic_func(llargument_tys, &llreturn_ty)
-    } else {
-        Type::func(llargument_tys, &llreturn_ty)
-    }
+    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,11 +285,6 @@ 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,7 +375,6 @@ 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,12 +154,6 @@ 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)
     }