auto merge of #10064 : luqmana/rust/vvv, r=nikomatsakis

Fixes #2057. Example: ```Rust #[no_std]; type c_char = u8; type c_int = i32; type size_t = uint; extern { fn printf(format: *c_char, ...) -> c_int; } #[lang="fail_bounds_check"] fn fail_bounds_check(_: *c_char, _: size_t, _: size_t, _: size_t) {} #[start] #[fixed_stack_segment] fn main(_: int, _: **u8) -> int { unsafe { let msg = bytes!("Hello World!

Author: bors

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,

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

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);
 }
 

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,

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 {

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);
  }

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)
  }

src/librustc/middle/ty.rs

@@ -433,12 +433,15 @@ pub struct ClosureTy {
  *
  * - `lifetimes` is the list of region names bound in this fn.
  * - `inputs` is the list of arguments and their modes.
- * - `output` is the return type. */
+ * - `output` is the return type.
+ * - `variadic` indicates whether this is a varidic function. (only true for foreign fns)
+ */
 #[deriving(Clone, Eq, IterBytes)]
 pub struct FnSig {
  bound_lifetime_names: OptVec<ast::Ident>,
  inputs: ~[t],
- output: t
+ output: t,
+ variadic: bool
 }
 
 #[deriving(Clone, Eq, IterBytes)]
@@ -705,6 +708,7 @@ pub enum type_err {
  terr_float_mismatch(expected_found<ast::float_ty>),
  terr_traits(expected_found<ast::DefId>),
  terr_builtin_bounds(expected_found<BuiltinBounds>),
+ terr_variadic_mismatch(expected_found<bool>)
 }
 
 #[deriving(Eq, IterBytes)]
@@ -1251,7 +1255,8 @@ pub fn mk_ctor_fn(cx: ctxt, input_tys: &[ty::t], output: ty::t) -> t {
  sig: FnSig {
  bound_lifetime_names: opt_vec::Empty,
  inputs: input_args,
- output: output
+ output: output,
+ variadic: false
  }
  })
 }
@@ -1338,7 +1343,8 @@ pub fn fold_sig(sig: &FnSig, fldop: &fn(t) -> t) -> FnSig {
  FnSig {
  bound_lifetime_names: sig.bound_lifetime_names.clone(),
  inputs: args,
- output: fldop(sig.output)
+ output: fldop(sig.output),
+ variadic: sig.variadic
  }
 }
 
@@ -2816,6 +2822,16 @@ fn node_id_has_type_params(cx: ctxt, id: ast::NodeId) -> bool {
  cx.node_type_substs.contains_key(&id)
 }
 
+pub fn fn_is_variadic(fty: t) -> bool {
+ match get(fty).sty {
+ ty_bare_fn(ref f) => f.sig.variadic,
+ ty_closure(ref f) => f.sig.variadic,
+ ref s => {
+ fail!("fn_is_variadic() called on non-fn type: {:?}", s)
+ }
+ }
+}
+
 pub fn ty_fn_sig(fty: t) -> FnSig {
  match get(fty).sty {
  ty_bare_fn(ref f) => f.sig.clone(),
@@ -3579,6 +3595,11 @@ pub fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
  values.expected.to_str(),
  values.found.to_str())
  }
+ terr_variadic_mismatch(ref values) => {
+ format!("expected {} fn but found {} function",
+ if values.expected { "variadic" } else { "non-variadic" },
+ if values.found { "variadic" } else { "non-variadic" })
+ }
  }
 }
 

src/librustc/middle/typeck/astconv.rs

@@ -396,6 +396,9 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope + Clone + 'static>(
  ty::mk_tup(tcx, flds)
  }
  ast::ty_bare_fn(ref bf) => {
+ if bf.decl.variadic && !bf.abis.is_c() {
+ tcx.sess.span_err(ast_ty.span, "variadic function must have C calling convention");
+ }
  ty::mk_bare_fn(tcx, ty_of_bare_fn(this, rscope, bf.purity,
  bf.abis, &bf.lifetimes, &bf.decl))
  }
@@ -660,9 +663,12 @@ fn ty_of_method_or_bare_fn<AC:AstConv,RS:RegionScope + Clone + 'static>(
  ty::BareFnTy {
  purity: purity,
  abis: abi,
- sig: ty::FnSig {bound_lifetime_names: bound_lifetime_names,
- inputs: input_tys,
- output: output_ty}
+ sig: ty::FnSig {
+ bound_lifetime_names: bound_lifetime_names,
+ inputs: input_tys,
+ output: output_ty,
+ variadic: decl.variadic
+ }
  });
 
  fn transform_self_ty<AC:AstConv,RS:RegionScope + Clone + 'static>(
@@ -770,9 +776,12 @@ pub fn ty_of_closure<AC:AstConv,RS:RegionScope + Clone + 'static>(
  onceness: onceness,
  region: bound_region,
  bounds: bounds,
- sig: ty::FnSig {bound_lifetime_names: bound_lifetime_names,
- inputs: input_tys,
- output: output_ty}
+ sig: ty::FnSig {
+ bound_lifetime_names: bound_lifetime_names,
+ inputs: input_tys,
+ output: output_ty,
+ variadic: decl.variadic
+ }
  }
 }