Add notail_when_called attribute and use it on panic functions.

Author: Zoxc

src/libcore/lib.rs

@@ -91,6 +91,7 @@
 #![feature(untagged_unions)]
 #![feature(unwind_attributes)]
 #![feature(doc_spotlight)]
+#![cfg_attr(not(stage0), feature(notail_when_called))]
 
 #[prelude_import]
 #[allow(unused)]

src/libcore/panicking.rs

@@ -48,7 +48,7 @@ pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
     // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the
     // output binary, saving up to a few kilobytes.
     let (expr, file, line, col) = *expr_file_line_col;
-    panic_dispatch(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col), &(panic as usize))
+    panic_dispatch(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col), panic as usize);
 }
 
 #[cold] #[inline(never)]
@@ -58,18 +58,20 @@ fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
     panic_dispatch(format_args!("index out of bounds: the len is {} but the index is {}",
                                 len, index),
                    file_line_col,
-                   &(panic_bounds_check as usize))
+                   panic_bounds_check as usize);
 }
 
 #[cold] #[inline(never)]
 pub fn panic_fmt(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
-    panic_dispatch(fmt, file_line_col, &(panic_fmt as usize));
+    panic_dispatch(fmt, file_line_col, panic_fmt as usize);
 }
 
 #[cold]
+#[inline(never)]
+#[cfg_attr(not(stage0), notail_when_called)]
 fn panic_dispatch(fmt: fmt::Arguments,
                  file_line_col: &(&'static str, u32, u32),
-                 entry_point: &usize) -> ! {
+                 entry_point: usize) -> ! {
     #[allow(improper_ctypes)]
     extern {
         #[lang = "panic_fmt"]
@@ -78,7 +80,7 @@ fn panic_dispatch(fmt: fmt::Arguments,
                       file: &'static str,
                       line: u32,
                       col: u32,
-                      entry_point: &usize) -> !;
+                      entry_point: usize) -> !;
     }
     let (file, line, col) = *file_line_col;
     unsafe { panic_impl(fmt, file, line, col, entry_point) }

src/librustc/hir/check_attr.rs

@@ -50,15 +50,16 @@ impl<'a> CheckAttrVisitor<'a> {
     fn check_attribute(&self, attr: &ast::Attribute, item: &ast::Item, target: Target) {
         if let Some(name) = attr.name() {
             match &*name.as_str() {
-                "inline" => self.check_inline(attr, item, target),
+                "inline" => self.check_target_function(attr, item, target),
+                "notail_when_called" => self.check_target_function(attr, item, target),
                 "repr" => self.check_repr(attr, item, target),
                 _ => (),
             }
         }
     }
 
-    /// Check if an `#[inline]` is applied to a function.
-    fn check_inline(&self, attr: &ast::Attribute, item: &ast::Item, target: Target) {
+    /// Check if the attribute is applied to a function.
+    fn check_target_function(&self, attr: &ast::Attribute, item: &ast::Item, target: Target) {
         if target != Target::Fn {
             struct_span_err!(self.sess, attr.span, E0518, "attribute should be applied to function")
                 .span_label(item.span, "not a function")

src/librustc_llvm/ffi.rs

@@ -1150,6 +1150,7 @@ extern "C" {
                              Bundle: OperandBundleDefRef,
                              Name: *const c_char)
                              -> ValueRef;
+    pub fn LLVMRustSetCallNoTail(Call: ValueRef);
     pub fn LLVMBuildSelect(B: BuilderRef,
                            If: ValueRef,
                            Then: ValueRef,

src/librustc_trans/mir/block.rs

@@ -118,7 +118,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
             llargs: &[ValueRef],
             destination: Option<(ReturnDest<'tcx>, mir::BasicBlock)>,
             cleanup: Option<mir::BasicBlock>
-        | {
+        | -> Option<ValueRef> {
             if let Some(cleanup) = cleanup {
                 let ret_bcx = if let Some((_, target)) = destination {
                     this.blocks[target]
@@ -137,6 +137,8 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                     this.set_debug_loc(&ret_bcx, terminator.source_info);
                     this.store_return(&ret_bcx, ret_dest, &fn_ty.ret, invokeret);
                 }
+
+                None
             } else {
                 let llret = bcx.call(fn_ptr, &llargs, cleanup_bundle);
                 fn_ty.apply_attrs_callsite(llret);
@@ -154,6 +156,8 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 } else {
                     bcx.unreachable();
                 }
+
+                Some(llret)
             }
         };
 
@@ -209,9 +213,9 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
             mir::TerminatorKind::Return => {
                 let llval = match self.fn_ty.ret.mode {
                     PassMode::Ignore | PassMode::Indirect(_) => {
-                        bcx.ret_void();
-                        return;
-                    }
+                    bcx.ret_void();
+                    return;
+                }
 
                     PassMode::Direct(_) | PassMode::Pair(..) => {
                         let op = self.trans_consume(&bcx, &mir::Place::Local(mir::RETURN_PLACE));
@@ -224,27 +228,27 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
 
                     PassMode::Cast(cast_ty) => {
                         let op = match self.locals[mir::RETURN_PLACE] {
-                            LocalRef::Operand(Some(op)) => op,
-                            LocalRef::Operand(None) => bug!("use of return before def"),
+                        LocalRef::Operand(Some(op)) => op,
+                        LocalRef::Operand(None) => bug!("use of return before def"),
                             LocalRef::Place(tr_place) => {
-                                OperandRef {
+                            OperandRef {
                                     val: Ref(tr_place.llval, tr_place.alignment),
                                     layout: tr_place.layout
-                                }
                             }
-                        };
-                        let llslot = match op.val {
-                            Immediate(_) | Pair(..) => {
+                        }
+                    };
+                    let llslot = match op.val {
+                        Immediate(_) | Pair(..) => {
                                 let scratch = PlaceRef::alloca(&bcx, self.fn_ty.ret.layout, "ret");
                                 op.val.store(&bcx, scratch);
                                 scratch.llval
-                            }
-                            Ref(llval, align) => {
-                                assert_eq!(align, Alignment::AbiAligned,
+                        }
+                        Ref(llval, align) => {
+                            assert_eq!(align, Alignment::AbiAligned,
                                            "return place is unaligned!");
-                                llval
-                            }
-                        };
+                            llval
+                        }
+                    };
                         bcx.load(
                             bcx.pointercast(llslot, cast_ty.llvm_type(bcx.ccx).ptr_to()),
                             Some(self.fn_ty.ret.layout.align))
@@ -448,6 +452,11 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 let sig = callee.layout.ty.fn_sig(bcx.tcx());
                 let sig = bcx.tcx().erase_late_bound_regions_and_normalize(&sig);
                 let abi = sig.abi;
+                let notail = def.map(|def| {
+                    def.attrs(bcx.ccx.tcx())
+                       .iter()
+                       .any(|attr| attr.check_name("notail_when_called"))
+                }).unwrap_or(false);
 
                 // Handle intrinsics old trans wants Expr's for, ourselves.
                 let intrinsic = match def {
@@ -508,28 +517,28 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                         ReturnDest::Store(dst) => dst.llval,
                         ReturnDest::DirectOperand(_) =>
                             bug!("Cannot use direct operand with an intrinsic call")
-                    };
+                };
 
                     let args: Vec<_> = args.iter().enumerate().map(|(i, arg)| {
-                        // The indices passed to simd_shuffle* in the
-                        // third argument must be constant. This is
-                        // checked by const-qualification, which also
-                        // promotes any complex rvalues to constants.
+                    // The indices passed to simd_shuffle* in the
+                    // third argument must be constant. This is
+                    // checked by const-qualification, which also
+                    // promotes any complex rvalues to constants.
                         if i == 2 && intrinsic.unwrap().starts_with("simd_shuffle") {
-                            match *arg {
+                        match *arg {
                                 mir::Operand::Copy(_) |
                                 mir::Operand::Move(_) => {
-                                    span_bug!(span, "shuffle indices must be constant");
-                                }
-                                mir::Operand::Constant(ref constant) => {
-                                    let val = self.trans_constant(&bcx, constant);
+                                span_bug!(span, "shuffle indices must be constant");
+                            }
+                            mir::Operand::Constant(ref constant) => {
+                                let val = self.trans_constant(&bcx, constant);
                                     return OperandRef {
                                         val: Immediate(val.llval),
                                         layout: bcx.ccx.layout_of(val.ty)
                                     };
-                                }
                             }
                         }
+                    }
 
                         self.trans_operand(&bcx, arg)
                     }).collect();
@@ -597,9 +606,14 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                     _ => span_bug!(span, "no llfn for call"),
                 };
 
-                do_call(self, bcx, fn_ty, fn_ptr, &llargs,
+                let llret = do_call(self, bcx, fn_ty, fn_ptr, &llargs,
                         destination.as_ref().map(|&(_, target)| (ret_dest, target)),
                         cleanup);
+                if notail {
+                    unsafe {
+                        llret.map(|llret| llvm::LLVMRustSetCallNoTail(llret));
+                    }
+                }
             }
             mir::TerminatorKind::GeneratorDrop |
             mir::TerminatorKind::Yield { .. } |
@@ -615,21 +629,21 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
         // Fill padding with undef value, where applicable.
         if let Some(ty) = arg.pad {
             llargs.push(C_undef(ty.llvm_type(bcx.ccx)));
-        }
+                    }
 
         if arg.is_ignore() {
             return;
-        }
+                }
 
         if let PassMode::Pair(..) = arg.mode {
             match op.val {
                 Pair(a, b) => {
                     llargs.push(a);
                     llargs.push(b);
-                    return;
-                }
-                _ => bug!("trans_argument: {:?} invalid for pair arugment", op)
+                return;
             }
+                _ => bug!("trans_argument: {:?} invalid for pair arugment", op)
+        }
         }
 
         // Force by-ref if we have to load through a cast pointer.
@@ -640,10 +654,10 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                         let scratch = PlaceRef::alloca(bcx, arg.layout, "arg");
                         op.val.store(bcx, scratch);
                         (scratch.llval, Alignment::AbiAligned, true)
-                    }
+                }
                     _ => {
                         (op.immediate_or_packed_pair(bcx), Alignment::AbiAligned, false)
-                    }
+            }
                 }
             }
             Ref(llval, align @ Alignment::Packed(_)) if arg.is_indirect() => {
@@ -674,8 +688,8 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 if let layout::Abi::Scalar(ref scalar) = arg.layout.abi {
                     if scalar.is_bool() {
                         bcx.range_metadata(llval, 0..2);
-                    }
-                }
+            }
+        }
                 // We store bools as i8 so we need to truncate to i1.
                 llval = base::to_immediate(bcx, llval, arg.layout);
             }
@@ -697,15 +711,15 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
             for i in 0..tuple.layout.fields.count() {
                 let field_ptr = tuple_ptr.project_field(bcx, i);
                 self.trans_argument(bcx, field_ptr.load(bcx), llargs, &args[i]);
-            }
-        } else {
+                }
+                } else {
             // If the tuple is immediate, the elements are as well.
             for i in 0..tuple.layout.fields.count() {
                 let op = tuple.extract_field(bcx, i);
                 self.trans_argument(bcx, op, llargs, &args[i]);
+                    }
+                }
             }
-        }
-    }
 
     fn get_personality_slot(&mut self, bcx: &Builder<'a, 'tcx>) -> PlaceRef<'tcx> {
         let ccx = bcx.ccx;

src/libstd/lib.rs

@@ -321,6 +321,7 @@
 #![feature(doc_cfg)]
 #![feature(doc_masked)]
 #![feature(doc_spotlight)]
+#![cfg_attr(not(stage0), feature(notail_when_called))]
 #![cfg_attr(test, feature(update_panic_count))]
 #![cfg_attr(windows, feature(used))]
 

src/libstd/panicking.rs

@@ -496,7 +496,7 @@ pub extern fn rust_begin_panic(msg: fmt::Arguments,
                                file: &'static str,
                                line: u32,
                                col: u32,
-                               entry_point: &usize) -> ! {
+                               entry_point: usize) -> ! {
     rust_panic_fmt(&msg, &(file, line, col), entry_point)
 }
 
@@ -511,13 +511,15 @@ pub extern fn rust_begin_panic(msg: fmt::Arguments,
            issue = "0")]
 #[inline(never)] #[cold]
 pub fn begin_panic_fmt(msg: &fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
-    rust_panic_fmt(msg, file_line_col, &(begin_panic_fmt as usize))
+    rust_panic_fmt(msg, file_line_col, begin_panic_fmt as usize);
 }
 
 #[cold]
+#[inline(never)]
+#[cfg_attr(not(stage0), notail_when_called)]
 fn rust_panic_fmt(msg: &fmt::Arguments,
                   file_line_col: &(&'static str, u32, u32),
-                  entry_point: &usize) -> ! {
+                  entry_point: usize) -> ! {
     use fmt::Write;
 
     // We do two allocations here, unfortunately. But (a) they're
@@ -543,7 +545,7 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
     // be performed in the parent of this thread instead of the thread that's
     // panicking.
 
-    rust_panic_with_hook(Box::new(msg), file_line_col, &(begin_panic::<M> as usize))
+    rust_panic_with_hook(Box::new(msg), file_line_col, begin_panic::<M> as usize)
 }
 
 /// Executes the primary logic for a panic, including checking for recursive
@@ -553,10 +555,11 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
 /// `Box<Any>` panics. Here we'll verify that we're not panicking recursively,
 /// run panic hooks, and then delegate to the actual implementation of panics.
 #[inline(never)]
+#[cfg_attr(not(stage0), notail_when_called)]
 #[cold]
 fn rust_panic_with_hook(msg: Box<Any + Send>,
                         file_line_col: &(&'static str, u32, u32),
-                        entry_point: &usize) -> ! {
+                        entry_point: usize) -> ! {
     let (file, line, col) = *file_line_col;
 
     let panics = update_panic_count(1);
@@ -580,7 +583,7 @@ fn rust_panic_with_hook(msg: Box<Any + Send>,
                 line,
                 col,
             },
-            entry_point: *entry_point,
+            entry_point,
         };
         HOOK_LOCK.read();
         match HOOK {