Allow for unwinding out of foreign abi functions

We were not allowing for the possibility that we might unwind out of a
foreign abi function. Now that we allow for some of these functions to
unwind, generate the proper code so clean-ups are performed.

This also allowed me to write a test for the functionality, which I have
now done.

Author: Aatch

src/librustc_trans/trans/build.rs

@@ -126,6 +126,25 @@ pub fn Invoke(cx: Block,
     B(cx).invoke(fn_, args, then, catch, attributes)
 }
 
+pub fn InvokeWithConv(cx: Block,
+                      fn_: ValueRef,
+                      args: &[ValueRef],
+                      then: BasicBlockRef,
+                      catch: BasicBlockRef,
+                      conv: CallConv,
+                      attributes: Option<AttrBuilder>)
+                      -> ValueRef {
+    if cx.unreachable.get() {
+        return C_null(Type::i8(cx.ccx()));
+    }
+    check_not_terminated(cx);
+    terminate(cx, "InvokeWithConv");
+    debug!("InvokeWithConv({} with arguments ({}))",
+           cx.val_to_string(fn_),
+           args.iter().map(|a| cx.val_to_string(*a)).collect::<Vec<String>>().connect(", "));
+    B(cx).invoke_with_conv(fn_, args, then, catch, conv, attributes)
+}
+
 pub fn Unreachable(cx: Block) {
     if cx.unreachable.get() {
         return

src/librustc_trans/trans/builder.rs

@@ -184,6 +184,40 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
+    pub fn invoke_with_conv(&self,
+                            llfn: ValueRef,
+                            args: &[ValueRef],
+                            then: BasicBlockRef,
+                            catch: BasicBlockRef,
+                            conv: CallConv,
+                            attributes: Option<AttrBuilder>)
+                            -> ValueRef {
+        self.count_insn("invokewithconv");
+
+        debug!("Invoke {} with args ({})",
+               self.ccx.tn().val_to_string(llfn),
+               args.iter()
+                   .map(|&v| self.ccx.tn().val_to_string(v))
+                   .collect::<Vec<String>>()
+                   .connect(", "));
+
+        unsafe {
+            let v = llvm::LLVMBuildInvoke(self.llbuilder,
+                                          llfn,
+                                          args.as_ptr(),
+                                          args.len() as c_uint,
+                                          then,
+                                          catch,
+                                          noname());
+            match attributes {
+                Some(a) => a.apply_callsite(v),
+                None => {}
+            }
+            llvm::SetInstructionCallConv(v, conv);
+            v
+        }
+    }
+
     pub fn unreachable(&self) {
         self.count_insn("unreachable");
         unsafe {

src/librustc_trans/trans/foreign.rs

@@ -17,6 +17,7 @@ use trans::base::{llvm_linkage_by_name, push_ctxt};
 use trans::base;
 use trans::build::*;
 use trans::cabi;
+use trans::cleanup::CleanupMethods;
 use trans::common::*;
 use trans::machine;
 use trans::monomorphize;
@@ -366,11 +367,27 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         arg_idx += 1;
     }
 
-    let llforeign_retval = CallWithConv(bcx,
-                                        llfn,
-                                        &llargs_foreign[],
-                                        cc,
-                                        Some(attrs));
+    // Foreign functions *can* unwind, albeit rarely, so use invoke instead of call.
+    // We shouldn't really be emitting an invoke all the time, LLVM can optimise them
+    // out, but we should be able avoid it most of the time
+    let (llforeign_retval, bcx) = if base::need_invoke(bcx) {
+        let normal_bcx = bcx.fcx.new_temp_block("normal-return");
+        let landing_pad = bcx.fcx.get_landing_pad();
+
+        let ret = InvokeWithConv(bcx, llfn, &llargs_foreign[],
+                                 normal_bcx.llbb,
+                                 landing_pad,
+                                 cc,
+                                 Some(attrs));
+        (ret, normal_bcx)
+    } else {
+        let ret = CallWithConv(bcx,
+                               llfn,
+                               &llargs_foreign[],
+                               cc,
+                               Some(attrs));
+        (ret, bcx)
+    };
 
     // If the function we just called does not use an outpointer,
     // store the result into the rust outpointer. Cast the outpointer

src/test/run-pass/ffi-unwinding.rs

@@ -0,0 +1,67 @@
+// Copyright 2013-2014 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(unwinding_attributes)]
+
+use std::io::Command;
+use std::os;
+use std::str;
+
+struct Guard { name: &'static str }
+
+impl Drop for Guard {
+    fn drop(&mut self) {
+        println!("Dropped Guard {}", self.name);
+    }
+}
+
+fn main() {
+    let args = os::args();
+
+    if args.len() > 1 {
+        if &args[1][] == "abort" {
+            let _g = Guard { name: "abort" };
+
+            i_abort();
+
+            return;
+        } else if &args[1][] == "unwind" {
+            let _g = Guard { name: "unwind" };
+
+            i_unwind();
+
+            return;
+        }
+    }
+
+    let p = Command::new(&args[0][])
+        .arg("abort")
+        .spawn().unwrap().wait_with_output().unwrap();
+
+    assert!(!p.status.success());
+    let mut lines = str::from_utf8(&p.output[]).unwrap().lines();
+
+    assert!(lines.next().is_none());
+
+    let p = Command::new(&args[0][])
+        .arg("unwind")
+        .spawn().unwrap().wait_with_output().unwrap();
+
+    assert!(!p.status.success());
+    let mut lines = str::from_utf8(&p.output[]).unwrap().lines();
+
+    assert_eq!(&lines.next().unwrap()[], "Dropped Guard unwind");
+}
+
+#[inline(never)]
+extern "C" fn i_abort() { panic!() }
+
+#[inline(never)] #[can_unwind]
+extern "C" fn i_unwind() { panic!() }