[MIR] Implement extern call support

src/librustc_trans/trans/mir/block.rs

@@ -9,13 +9,16 @@
 // except according to those terms.
 
 use llvm::{BasicBlockRef, ValueRef};
+use rustc::middle::ty;
 use rustc::mir::repr as mir;
+use syntax::abi::Abi;
 use trans::adt;
+use trans::attributes;
 use trans::base;
 use trans::build;
-use trans::attributes;
 use trans::common::{self, Block};
 use trans::debuginfo::DebugLoc;
+use trans::foreign;
 use trans::type_of;
 use trans::type_::Type;
 
@@ -57,7 +60,6 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
  // The else branch of the Switch can't be hit, so branch to an unreachable
  // instruction so LLVM knows that
  let unreachable_blk = self.unreachable_block();
-
  let switch = build::Switch(bcx, discr, unreachable_blk.llbb, targets.len());
  assert_eq!(adt_def.variants.len(), targets.len());
  for (adt_variant, target) in adt_def.variants.iter().zip(targets) {
@@ -98,12 +100,24 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
  let debugloc = DebugLoc::None;
  // The arguments we'll be passing. Plus one to account for outptr, if used.
  let mut llargs = Vec::with_capacity(args.len() + 1);
+ // Types of the arguments. We do not preallocate, because this vector is only
+ // filled when `is_foreign` is `true` and foreign calls are minority of the cases.
+ let mut arg_tys = Vec::new();
+
+ // Foreign-ABI functions are translated differently
+ let is_foreign = if let ty::TyBareFn(_, ref f) = callee.ty.sty {
+ // We do not translate intrinsics here (they shouldn’t be functions)
+ assert!(f.abi != Abi::RustIntrinsic && f.abi != Abi::PlatformIntrinsic);
+ f.abi != Abi::Rust && f.abi != Abi::RustCall
+ } else {
+ false
+ };
 
  // Prepare the return value destination
  let (ret_dest_ty, must_copy_dest) = if let Some(d) = kind.destination() {
  let dest = self.trans_lvalue(bcx, d);
  let ret_ty = dest.ty.to_ty(bcx.tcx());
- if type_of::return_uses_outptr(bcx.ccx(), ret_ty) {
+ if !is_foreign && type_of::return_uses_outptr(bcx.ccx(), ret_ty) {
  llargs.push(dest.llval);
  (Some((dest, ret_ty)), false)
  } else {
@@ -115,30 +129,35 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
 
  // Process the rest of the args.
  for arg in args {
- match self.trans_operand(bcx, arg).val {
+ let operand = self.trans_operand(bcx, arg);
+ match operand.val {
  Ref(llval) | Immediate(llval) => llargs.push(llval),
  FatPtr(b, e) => {
  llargs.push(b);
  llargs.push(e);
  }
  }
+ if is_foreign {
+ arg_tys.push(operand.ty);
+ }
  }
 
  // Many different ways to call a function handled here
- match (base::avoid_invoke(bcx), kind) {
+ match (is_foreign, base::avoid_invoke(bcx), kind) {
  // The two cases below are the only ones to use LLVM’s `invoke`.
- (false, &mir::CallKind::DivergingCleanup(cleanup)) => {
+ (false, false, &mir::CallKind::DivergingCleanup(cleanup)) => {
  let cleanup = self.bcx(cleanup);
  let landingpad = self.make_landing_pad(cleanup);
+ let unreachable_blk = self.unreachable_block();
  build::Invoke(bcx,
  callee.immediate(),
  &llargs[..],
- self.unreachable_block().llbb,
+ unreachable_blk.llbb,
  landingpad.llbb,
  Some(attrs),
  debugloc);
  },
- (false, &mir::CallKind::ConvergingCleanup { ref targets, .. }) => {
+ (false, false, &mir::CallKind::ConvergingCleanup { ref targets, .. }) => {
  let cleanup = self.bcx(targets.1);
  let landingpad = self.make_landing_pad(cleanup);
  let (target, postinvoke) = if must_copy_dest {
@@ -184,14 +203,14 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
  build::Br(target, postinvoketarget.llbb, debugloc);
  }
  },
- (_, &mir::CallKind::DivergingCleanup(_)) |
- (_, &mir::CallKind::Diverging) => {
+ (false, _, &mir::CallKind::DivergingCleanup(_)) |
+ (false, _, &mir::CallKind::Diverging) => {
  build::Call(bcx, callee.immediate(), &llargs[..], Some(attrs), debugloc);
  build::Unreachable(bcx);
  }
- (_, k@&mir::CallKind::ConvergingCleanup { .. }) |
- (_, k@&mir::CallKind::Converging { .. }) => {
- // Bug #20046
+ (false, _, k@&mir::CallKind::ConvergingCleanup { .. }) |
+ (false, _, k@&mir::CallKind::Converging { .. }) => {
+ // FIXME: Bug #20046
  let target = match *k {
  mir::CallKind::ConvergingCleanup { targets, .. } => targets.0,
  mir::CallKind::Converging { target, .. } => target,
@@ -209,6 +228,25 @@ impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
  }
  build::Br(bcx, self.llblock(target), debugloc);
  }
+ // Foreign functions
+ (true, _, k) => {
+ let (dest, _) = ret_dest_ty
+ .expect("return destination is not set");
+ bcx = foreign::trans_native_call(bcx,
+ callee.ty,
+ callee.immediate(),
+ dest.llval,
+ &llargs[..],
+ arg_tys,
+ debugloc);
+ match *k {
+ mir::CallKind::ConvergingCleanup { targets, .. } =>
+ build::Br(bcx, self.llblock(targets.0), debugloc),
+ mir::CallKind::Converging { target, .. } =>
+ build::Br(bcx, self.llblock(target), debugloc),
+ _ => ()
+ };
+ },
  }
  }
  }

src/rt/rust_test_helpers.c

@@ -12,6 +12,7 @@
 
 #include <stdint.h>
 #include <assert.h>
+#include <stdarg.h>
 
 // These functions are used in the unit tests for C ABI calls.
 
@@ -222,3 +223,18 @@ uint64_t get_z(struct S s) {
 uint64_t get_c_many_params(void *a, void *b, void *c, void *d, struct quad f) {
  return f.c;
 }
+
+// Calculates the average of `(x + y) / n` where x: i64, y: f64. There must be exactly n pairs
+// passed as variadic arguments.
+double rust_interesting_average(uint64_t n, ...) {
+ va_list pairs;
+ double sum = 0.0;
+ int i;
+ va_start(pairs, n);
+ for(i = 0; i < n; i += 1) {
+ sum += (double)va_arg(pairs, int64_t);
+ sum += va_arg(pairs, double);
+ }
+ va_end(pairs);
+ return sum / n;
+}

src/test/run-pass/mir_trans_calls.rs

@@ -88,6 +88,15 @@ fn test8() -> isize {
  Two::two()
 }
 
+extern fn simple_extern(x: u32, y: (u32, u32)) -> u32 {
+ x + y.0 * y.1
+}
+
+#[rustc_mir]
+fn test9() -> u32 {
+ simple_extern(41, (42, 43))
+}
+
 #[rustc_mir]
 fn test_closure<F>(f: &F, x: i32, y: i32) -> i32
  where F: Fn(i32, i32) -> i32
@@ -117,6 +126,7 @@ fn main() {
  assert_eq!(test6(&Foo, 12367), 12367);
  assert_eq!(test7(), 1);
  assert_eq!(test8(), 2);
+ assert_eq!(test9(), 41 + 42 * 43);
 
  let closure = |x: i32, y: i32| { x + y };
  assert_eq!(test_closure(&closure, 100, 1), 101);

src/test/run-pass/mir_trans_calls_variadic.rs

@@ -0,0 +1,32 @@
+// 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.
+
+#![feature(rustc_attrs)]
+
+#[link(name = "rust_test_helpers")]
+extern {
+ fn rust_interesting_average(_: i64, ...) -> f64;
+}
+
+#[rustc_mir]
+fn test(a: i64, b: i64, c: i64, d: i64, e: i64, f: i64) -> i64 {
+ unsafe {
+ rust_interesting_average(6, a, a as f64,
+ b, b as f64,
+ c, c as f64,
+ d, d as f64,
+ e, e as f64,
+ f, f as f64) as i64
+ }
+}
+
+fn main(){
+ assert_eq!(test(10, 20, 30, 40, 50, 60), 70);
+}