From dc7e478d626269425870ef281dd8aee11a4b50ef Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 26 Dec 2019 10:02:21 -0500
Subject: [PATCH 01/21] Inline catching panics into std::catch_unwind

This allows LLVM to inline the happy path, such that catching unwinding is
zero-cost when no panic occurs. This also allows us to match the code generated
by C++ try/catch.
---
 src/libpanic_abort/lib.rs     | 13 ++-----
 src/libpanic_unwind/dummy.rs  |  4 +-
 src/libpanic_unwind/emcc.rs   |  4 +-
 src/libpanic_unwind/gcc.rs    |  5 +--
 src/libpanic_unwind/hermit.rs |  4 +-
 src/libpanic_unwind/lib.rs    | 33 ++++-------------
 src/libpanic_unwind/seh.rs    |  4 +-
 src/libstd/panicking.rs       | 70 ++++++++++++++++++++++-------------
 8 files changed, 60 insertions(+), 77 deletions(-)

diff --git a/src/libpanic_abort/lib.rs b/src/libpanic_abort/lib.rs
index db7c250e21157..ebc57860b9d4a 100644
--- a/src/libpanic_abort/lib.rs
+++ b/src/libpanic_abort/lib.rs
@@ -17,18 +17,11 @@
 #![feature(panic_runtime)]
 #![feature(staged_api)]
 #![feature(rustc_attrs)]
+#![feature(raw)]
 
-// Rust's "try" function, but if we're aborting on panics we just call the
-// function as there's nothing else we need to do here.
 #[rustc_std_internal_symbol]
-pub unsafe extern "C" fn __rust_maybe_catch_panic(
-    f: fn(*mut u8),
-    data: *mut u8,
-    _data_ptr: *mut usize,
-    _vtable_ptr: *mut usize,
-) -> u32 {
-    f(data);
-    0
+pub unsafe extern "C" fn __rust_cleanup(_: *mut u8) -> core::raw::TraitObject {
+    unreachable!()
 }
 
 // "Leak" the payload and shim to the relevant abort on the platform in
diff --git a/src/libpanic_unwind/dummy.rs b/src/libpanic_unwind/dummy.rs
index 8675632638712..30593d3b88af9 100644
--- a/src/libpanic_unwind/dummy.rs
+++ b/src/libpanic_unwind/dummy.rs
@@ -6,9 +6,7 @@ use alloc::boxed::Box;
 use core::any::Any;
 use core::intrinsics;
 
-pub fn payload() -> *mut u8 {
-    core::ptr::null_mut()
-}
+pub type Payload = *mut u8;
 
 pub unsafe fn cleanup(_ptr: *mut u8) -> Box<dyn Any + Send> {
     intrinsics::abort()
diff --git a/src/libpanic_unwind/emcc.rs b/src/libpanic_unwind/emcc.rs
index 9161d49959cf5..873135414bd9d 100644
--- a/src/libpanic_unwind/emcc.rs
+++ b/src/libpanic_unwind/emcc.rs
@@ -48,9 +48,7 @@ static EXCEPTION_TYPE_INFO: TypeInfo = TypeInfo {
     name: b"rust_panic\0".as_ptr(),
 };
 
-pub fn payload() -> *mut u8 {
-    ptr::null_mut()
-}
+pub type Payload = *mut u8;
 
 struct Exception {
     // This needs to be an Option because the object's lifetime follows C++
diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs
index 591ff9d7fdcaa..dd84a814f48b1 100644
--- a/src/libpanic_unwind/gcc.rs
+++ b/src/libpanic_unwind/gcc.rs
@@ -48,7 +48,6 @@
 
 use alloc::boxed::Box;
 use core::any::Any;
-use core::ptr;
 
 use crate::dwarf::eh::{self, EHAction, EHContext};
 use libc::{c_int, uintptr_t};
@@ -83,9 +82,7 @@ pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
     }
 }
 
-pub fn payload() -> *mut u8 {
-    ptr::null_mut()
-}
+pub type Payload = *mut u8;
 
 pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
     let exception = Box::from_raw(ptr as *mut Exception);
diff --git a/src/libpanic_unwind/hermit.rs b/src/libpanic_unwind/hermit.rs
index 2f53df2861d44..8ffb4bcd3df23 100644
--- a/src/libpanic_unwind/hermit.rs
+++ b/src/libpanic_unwind/hermit.rs
@@ -6,9 +6,7 @@ use alloc::boxed::Box;
 use core::any::Any;
 use core::ptr;
 
-pub fn payload() -> *mut u8 {
-    ptr::null_mut()
-}
+pub type Payload = *mut u8;
 
 pub unsafe fn cleanup(_ptr: *mut u8) -> Box<dyn Any + Send> {
     extern "C" {
diff --git a/src/libpanic_unwind/lib.rs b/src/libpanic_unwind/lib.rs
index 6383ae39fb6db..60ddf70cea52f 100644
--- a/src/libpanic_unwind/lib.rs
+++ b/src/libpanic_unwind/lib.rs
@@ -22,20 +22,20 @@
 #![feature(libc)]
 #![feature(nll)]
 #![feature(panic_unwind)]
-#![feature(raw)]
 #![feature(staged_api)]
 #![feature(std_internals)]
 #![feature(unwind_attributes)]
 #![feature(abi_thiscall)]
+#![feature(rustc_attrs)]
+#![feature(raw)]
 #![panic_runtime]
 #![feature(panic_runtime)]
 
 use alloc::boxed::Box;
-use core::intrinsics;
-use core::mem;
 use core::panic::BoxMeUp;
-use core::raw;
 
+// If adding to this list, you should also look at libstd::panicking's identical
+// list of Payload types and likely add to there as well.
 cfg_if::cfg_if! {
     if #[cfg(target_os = "emscripten")] {
         #[path = "emcc.rs"]
@@ -69,28 +69,11 @@ extern "C" {
 
 mod dwarf;
 
-// Entry point for catching an exception, implemented using the `try` intrinsic
-// in the compiler.
-//
-// The interaction between the `payload` function and the compiler is pretty
-// hairy and tightly coupled, for more information see the compiler's
-// implementation of this.
 #[no_mangle]
-pub unsafe extern "C" fn __rust_maybe_catch_panic(
-    f: fn(*mut u8),
-    data: *mut u8,
-    data_ptr: *mut usize,
-    vtable_ptr: *mut usize,
-) -> u32 {
-    let mut payload = imp::payload();
-    if intrinsics::r#try(f, data, &mut payload as *mut _ as *mut _) == 0 {
-        0
-    } else {
-        let obj = mem::transmute::<_, raw::TraitObject>(imp::cleanup(payload));
-        *data_ptr = obj.data as usize;
-        *vtable_ptr = obj.vtable as usize;
-        1
-    }
+pub unsafe extern "C" fn __rust_panic_cleanup(payload: *mut u8) -> core::raw::TraitObject {
+    let payload = payload as *mut imp::Payload;
+    let payload = *(payload);
+    core::mem::transmute(imp::cleanup(payload))
 }
 
 // Entry point for raising an exception, just delegates to the platform-specific
diff --git a/src/libpanic_unwind/seh.rs b/src/libpanic_unwind/seh.rs
index 6f507e85e742c..6f464c1ab680e 100644
--- a/src/libpanic_unwind/seh.rs
+++ b/src/libpanic_unwind/seh.rs
@@ -308,9 +308,7 @@ pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
     _CxxThrowException(throw_ptr, &mut THROW_INFO as *mut _ as *mut _);
 }
 
-pub fn payload() -> [u64; 2] {
-    [0; 2]
-}
+pub type Payload = [u64; 2];
 
 pub unsafe fn cleanup(payload: [u64; 2]) -> Box<dyn Any + Send> {
     mem::transmute(raw::TraitObject { data: payload[0] as *mut _, vtable: payload[1] as *mut _ })
diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs
index 8b12aaaa7e2fd..f71849fae34fa 100644
--- a/src/libstd/panicking.rs
+++ b/src/libstd/panicking.rs
@@ -12,9 +12,8 @@ use core::panic::{BoxMeUp, Location, PanicInfo};
 use crate::any::Any;
 use crate::fmt;
 use crate::intrinsics;
-use crate::mem::{self, ManuallyDrop};
+use crate::mem::{self, ManuallyDrop, MaybeUninit};
 use crate::process;
-use crate::raw;
 use crate::sync::atomic::{AtomicBool, Ordering};
 use crate::sys::stdio::panic_output;
 use crate::sys_common::backtrace::{self, RustBacktrace};
@@ -29,6 +28,31 @@ use crate::io::set_panic;
 #[cfg(test)]
 use realstd::io::set_panic;
 
+// This must be kept in sync with the implementations in libpanic_unwind.
+//
+// This is *not* checked in anyway; the compiler does not allow us to use a
+// type/macro/anything from panic_unwind, since we're then linking in the
+// panic_unwind runtime even during -Cpanic=abort.
+//
+// Essentially this must be the type of `imp::Payload` in libpanic_unwind.
+cfg_if::cfg_if! {
+    if #[cfg(not(feature = "panic_unwind"))] {
+        type Payload = ();
+    } else if #[cfg(target_os = "emscripten")] {
+        type Payload = *mut u8;
+    } else if #[cfg(target_arch = "wasm32")] {
+        type Payload = *mut u8;
+    } else if #[cfg(target_os = "hermit")] {
+        type Payload = *mut u8;
+    } else if #[cfg(all(target_env = "msvc", target_arch = "aarch64"))] {
+        type Payload = *mut u8;
+    } else if #[cfg(target_env = "msvc")] {
+        type Payload = [u64; 2];
+    } else {
+        type Payload = *mut u8;
+    }
+}
+
 // Binary interface to the panic runtime that the standard library depends on.
 //
 // The standard library is tagged with `#![needs_panic_runtime]` (introduced in
@@ -41,12 +65,9 @@ use realstd::io::set_panic;
 // hook up these functions, but it is not this day!
 #[allow(improper_ctypes)]
 extern "C" {
-    fn __rust_maybe_catch_panic(
-        f: fn(*mut u8),
-        data: *mut u8,
-        data_ptr: *mut usize,
-        vtable_ptr: *mut usize,
-    ) -> u32;
+    /// The payload ptr here is actually the same as the payload ptr for the try
+    /// intrinsic (i.e., is really `*mut [u64; 2]` or `*mut *mut u8`).
+    fn __rust_panic_cleanup(payload: *mut u8) -> core::raw::TraitObject;
 
     /// `payload` is actually a `*mut &mut dyn BoxMeUp` but that would cause FFI warnings.
     /// It cannot be `Box<dyn BoxMeUp>` because the other end of this call does not depend
@@ -250,9 +271,9 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
     }
 
     // We do some sketchy operations with ownership here for the sake of
-    // performance. We can only  pass pointers down to
-    // `__rust_maybe_catch_panic` (can't pass objects by value), so we do all
-    // the ownership tracking here manually using a union.
+    // performance. We can only pass pointers down to `do_call` (can't pass
+    // objects by value), so we do all the ownership tracking here manually
+    // using a union.
     //
     // We go through a transition where:
     //
@@ -263,7 +284,7 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
     // * If the closure successfully returns, we write the return value into the
     //   data's return slot. Note that `ptr::write` is used as it's overwriting
     //   uninitialized data.
-    // * Finally, when we come back out of the `__rust_maybe_catch_panic` we're
+    // * Finally, when we come back out of the `try` intrinsic we're
     //   in one of two states:
     //
     //      1. The closure didn't panic, in which case the return value was
@@ -274,27 +295,24 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
     //
     // Once we stack all that together we should have the "most efficient'
     // method of calling a catch panic whilst juggling ownership.
-    let mut any_data = 0;
-    let mut any_vtable = 0;
     let mut data = Data { f: ManuallyDrop::new(f) };
 
-    let r = __rust_maybe_catch_panic(
-        do_call::<F, R>,
-        &mut data as *mut _ as *mut u8,
-        &mut any_data,
-        &mut any_vtable,
-    );
+    let mut payload: MaybeUninit<Payload> = MaybeUninit::uninit();
 
-    return if r == 0 {
+    let data_ptr = &mut data as *mut _ as *mut u8;
+    let payload_ptr = payload.as_mut_ptr() as *mut _;
+    return if intrinsics::r#try(do_call::<F, R>, data_ptr, payload_ptr) == 0 {
         Ok(ManuallyDrop::into_inner(data.r))
     } else {
-        update_panic_count(-1);
-        Err(mem::transmute(raw::TraitObject {
-            data: any_data as *mut _,
-            vtable: any_vtable as *mut _,
-        }))
+        Err(cleanup(payload.assume_init()))
     };
 
+    unsafe fn cleanup(mut payload: Payload) -> Box<dyn Any + Send + 'static> {
+        let obj = crate::mem::transmute(__rust_panic_cleanup(&mut payload as *mut _ as *mut u8));
+        update_panic_count(-1);
+        obj
+    }
+
     fn do_call<F: FnOnce() -> R, R>(data: *mut u8) {
         unsafe {
             let data = data as *mut Data<F, R>;

From b77267308d500dea20aca948e396f36b8f6a91f0 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 26 Dec 2019 10:03:41 -0500
Subject: [PATCH 02/21] Avoid over-aligning the return value in the
 -Cpanic=abort case

---
 src/librustc_codegen_llvm/intrinsic.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
index 3d1e72e1c73d7..32f0154fa50bf 100644
--- a/src/librustc_codegen_llvm/intrinsic.rs
+++ b/src/librustc_codegen_llvm/intrinsic.rs
@@ -858,8 +858,10 @@ fn try_intrinsic(
 ) {
     if bx.sess().no_landing_pads() {
         bx.call(func, &[data], None);
-        let ptr_align = bx.tcx().data_layout.pointer_align.abi;
-        bx.store(bx.const_null(bx.type_i8p()), dest, ptr_align);
+        // Return 0 unconditionally from the intrinsic call;
+        // we can never unwind.
+        let ret_align = bx.tcx().data_layout.i32_align.abi;
+        bx.store(bx.const_i32(0), dest, ret_align);
     } else if wants_msvc_seh(bx.sess()) {
         codegen_msvc_try(bx, func, data, local_ptr, dest);
     } else {

From 023c97e99887e1b4799122e7f6a807be1b4b1373 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Thu, 26 Dec 2019 10:37:48 -0500
Subject: [PATCH 03/21] Test catch_unwind vanishing

We execpt the try intrinsic to be a direct call if in -Cpanic=abort mode, and
that catch_unwind optimizes out if calling a function that does not unwind.
---
 src/test/codegen/catch-unwind.rs    | 19 +++++++++++++++++++
 src/test/codegen/try-panic-abort.rs | 17 +++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 src/test/codegen/catch-unwind.rs
 create mode 100644 src/test/codegen/try-panic-abort.rs

diff --git a/src/test/codegen/catch-unwind.rs b/src/test/codegen/catch-unwind.rs
new file mode 100644
index 0000000000000..3c9bc35d1c8bd
--- /dev/null
+++ b/src/test/codegen/catch-unwind.rs
@@ -0,0 +1,19 @@
+// compile-flags: -O
+
+#![crate_type = "lib"]
+
+extern "C" {
+    fn bar();
+}
+
+// CHECK-LABEL: @foo
+#[no_mangle]
+pub unsafe fn foo() -> i32 {
+    // CHECK: call void @bar
+    // CHECK: ret i32 0
+    std::panic::catch_unwind(|| {
+        bar();
+        0
+    })
+    .unwrap()
+}
diff --git a/src/test/codegen/try-panic-abort.rs b/src/test/codegen/try-panic-abort.rs
new file mode 100644
index 0000000000000..9bc89a321576c
--- /dev/null
+++ b/src/test/codegen/try-panic-abort.rs
@@ -0,0 +1,17 @@
+// compile-flags: -C panic=abort -O
+
+#![crate_type = "lib"]
+#![feature(unwind_attributes, core_intrinsics)]
+
+extern "C" {
+    #[unwind(allow)]
+    fn bar(data: *mut u8);
+}
+
+// CHECK-LABEL: @foo
+#[no_mangle]
+pub unsafe fn foo() -> i32 {
+    // CHECK: call void @bar
+    // CHECK: ret i32 0
+    std::intrinsics::r#try(|x| bar(x), 0 as *mut u8, 0 as *mut u8)
+}

From 72c3098d31eede2f224bf33a958c09e196f0f835 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 26 Dec 2019 10:49:16 -0500
Subject: [PATCH 04/21] Ignore PAL lint for std::panicking

---
 src/tools/tidy/src/pal.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index dcd4c9e8ef7d9..31fc6f10e8296 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -59,6 +59,8 @@ const EXCEPTION_PATHS: &[&str] = &[
     "src/libstd/sys_common/mod.rs",
     "src/libstd/sys_common/net.rs",
     "src/libstd/sys_common/backtrace.rs",
+    // panic_unwind shims
+    "src/libstd/panicking.rs",
     "src/libterm", // Not sure how to make this crate portable, but test crate needs it.
     "src/libtest", // Probably should defer to unstable `std::sys` APIs.
     "src/libstd/sync/mpsc", // some tests are only run on non-emscripten

From 6bfd6ad62da09686e5e2a44aa1939a279f286e9c Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Thu, 26 Dec 2019 10:54:24 -0500
Subject: [PATCH 05/21] Mark cleanup cold

---
 src/libstd/panicking.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs
index f71849fae34fa..3dd1f09e07656 100644
--- a/src/libstd/panicking.rs
+++ b/src/libstd/panicking.rs
@@ -307,6 +307,11 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
         Err(cleanup(payload.assume_init()))
     };
 
+    // We consider unwinding to be rare, so mark this function as cold. However,
+    // do not mark it no-inline -- that decision is best to leave to the
+    // optimizer (in most cases this function is not inlined even as a normal,
+    // non-cold function, though, as of the writing of this comment).
+    #[cold]
     unsafe fn cleanup(mut payload: Payload) -> Box<dyn Any + Send + 'static> {
         let obj = crate::mem::transmute(__rust_panic_cleanup(&mut payload as *mut _ as *mut u8));
         update_panic_count(-1);

From 05c97b9fd3307ac6f219f24d6ddc18813fb8a673 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Thu, 26 Dec 2019 19:37:14 +0100
Subject: [PATCH 06/21] Fix some minor issues

---
 src/libpanic_abort/lib.rs  | 5 +++--
 src/libpanic_unwind/lib.rs | 5 +++--
 src/libstd/panicking.rs    | 4 ++--
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/libpanic_abort/lib.rs b/src/libpanic_abort/lib.rs
index ebc57860b9d4a..fe9196ef2314b 100644
--- a/src/libpanic_abort/lib.rs
+++ b/src/libpanic_abort/lib.rs
@@ -17,10 +17,11 @@
 #![feature(panic_runtime)]
 #![feature(staged_api)]
 #![feature(rustc_attrs)]
-#![feature(raw)]
+
+use core::any::Any;
 
 #[rustc_std_internal_symbol]
-pub unsafe extern "C" fn __rust_cleanup(_: *mut u8) -> core::raw::TraitObject {
+pub unsafe extern "C" fn __rust_panic_cleanup(_: *mut u8) -> *mut (dyn Any + Send + 'static) {
     unreachable!()
 }
 
diff --git a/src/libpanic_unwind/lib.rs b/src/libpanic_unwind/lib.rs
index 60ddf70cea52f..ad82f22510c41 100644
--- a/src/libpanic_unwind/lib.rs
+++ b/src/libpanic_unwind/lib.rs
@@ -32,6 +32,7 @@
 #![feature(panic_runtime)]
 
 use alloc::boxed::Box;
+use core::any::Any;
 use core::panic::BoxMeUp;
 
 // If adding to this list, you should also look at libstd::panicking's identical
@@ -70,10 +71,10 @@ extern "C" {
 mod dwarf;
 
 #[no_mangle]
-pub unsafe extern "C" fn __rust_panic_cleanup(payload: *mut u8) -> core::raw::TraitObject {
+pub unsafe extern "C" fn __rust_panic_cleanup(payload: *mut u8) -> *mut (dyn Any + Send + 'static) {
     let payload = payload as *mut imp::Payload;
     let payload = *(payload);
-    core::mem::transmute(imp::cleanup(payload))
+    Box::into_raw(imp::cleanup(payload))
 }
 
 // Entry point for raising an exception, just delegates to the platform-specific
diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs
index 3dd1f09e07656..b02cedd5da5bf 100644
--- a/src/libstd/panicking.rs
+++ b/src/libstd/panicking.rs
@@ -67,7 +67,7 @@ cfg_if::cfg_if! {
 extern "C" {
     /// The payload ptr here is actually the same as the payload ptr for the try
     /// intrinsic (i.e., is really `*mut [u64; 2]` or `*mut *mut u8`).
-    fn __rust_panic_cleanup(payload: *mut u8) -> core::raw::TraitObject;
+    fn __rust_panic_cleanup(payload: *mut u8) -> *mut (dyn Any + Send + 'static);
 
     /// `payload` is actually a `*mut &mut dyn BoxMeUp` but that would cause FFI warnings.
     /// It cannot be `Box<dyn BoxMeUp>` because the other end of this call does not depend
@@ -313,7 +313,7 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
     // non-cold function, though, as of the writing of this comment).
     #[cold]
     unsafe fn cleanup(mut payload: Payload) -> Box<dyn Any + Send + 'static> {
-        let obj = crate::mem::transmute(__rust_panic_cleanup(&mut payload as *mut _ as *mut u8));
+        let obj = Box::from_raw(__rust_panic_cleanup(&mut payload as *mut _ as *mut u8));
         update_panic_count(-1);
         obj
     }

From 39aa3058511d85a756fe0deef59bca6ace71bfa5 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Sun, 29 Dec 2019 12:07:44 +0100
Subject: [PATCH 07/21] Ignore broken no-landing-pads test

---
 src/test/ui/no-landing-pads.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/test/ui/no-landing-pads.rs b/src/test/ui/no-landing-pads.rs
index d9d532106125a..44af25f7f8f48 100644
--- a/src/test/ui/no-landing-pads.rs
+++ b/src/test/ui/no-landing-pads.rs
@@ -1,6 +1,7 @@
 // run-pass
 // compile-flags: -Z no-landing-pads -C codegen-units=1
 // ignore-emscripten no threads support
+// ignore-test fails because catch_unwind doesn't work with no-landing-pads
 
 use std::thread;
 

From b3a07b197b28742166cbe3b72284f77d284d571a Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Tue, 7 Jan 2020 16:41:59 +0100
Subject: [PATCH 08/21] Apply review feedback

---
 Cargo.lock                     |  1 +
 src/libpanic_abort/Cargo.toml  |  1 +
 src/libpanic_abort/lib.rs      |  5 ++++-
 src/libpanic_unwind/dummy.rs   |  2 --
 src/libpanic_unwind/emcc.rs    |  2 --
 src/libpanic_unwind/gcc.rs     |  2 --
 src/libpanic_unwind/hermit.rs  |  2 --
 src/libpanic_unwind/lib.rs     | 12 +++++++-----
 src/libpanic_unwind/payload.rs | 21 +++++++++++++++++++++
 src/libpanic_unwind/seh.rs     |  2 --
 src/libstd/panicking.rs        | 34 ++++++----------------------------
 src/test/ui/no-landing-pads.rs | 24 ------------------------
 12 files changed, 40 insertions(+), 68 deletions(-)
 create mode 100644 src/libpanic_unwind/payload.rs
 delete mode 100644 src/test/ui/no-landing-pads.rs

diff --git a/Cargo.lock b/Cargo.lock
index beda3993353f4..6ffca04cafb7f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2308,6 +2308,7 @@ dependencies = [
 name = "panic_abort"
 version = "0.0.0"
 dependencies = [
+ "cfg-if",
  "compiler_builtins",
  "core",
  "libc",
diff --git a/src/libpanic_abort/Cargo.toml b/src/libpanic_abort/Cargo.toml
index 2bee0b716c750..8ebd95047ac23 100644
--- a/src/libpanic_abort/Cargo.toml
+++ b/src/libpanic_abort/Cargo.toml
@@ -14,3 +14,4 @@ doc = false
 core = { path = "../libcore" }
 libc = { version = "0.2", default-features = false }
 compiler_builtins = "0.1.0"
+cfg-if = "0.1.8"
diff --git a/src/libpanic_abort/lib.rs b/src/libpanic_abort/lib.rs
index fe9196ef2314b..6ea818ecef827 100644
--- a/src/libpanic_abort/lib.rs
+++ b/src/libpanic_abort/lib.rs
@@ -20,8 +20,11 @@
 
 use core::any::Any;
 
+// We need the definition of TryPayload for __rust_panic_cleanup.
+include!("../libpanic_unwind/payload.rs");
+
 #[rustc_std_internal_symbol]
-pub unsafe extern "C" fn __rust_panic_cleanup(_: *mut u8) -> *mut (dyn Any + Send + 'static) {
+pub unsafe extern "C" fn __rust_panic_cleanup(_: TryPayload) -> *mut (dyn Any + Send + 'static) {
     unreachable!()
 }
 
diff --git a/src/libpanic_unwind/dummy.rs b/src/libpanic_unwind/dummy.rs
index 30593d3b88af9..4667ede2baad5 100644
--- a/src/libpanic_unwind/dummy.rs
+++ b/src/libpanic_unwind/dummy.rs
@@ -6,8 +6,6 @@ use alloc::boxed::Box;
 use core::any::Any;
 use core::intrinsics;
 
-pub type Payload = *mut u8;
-
 pub unsafe fn cleanup(_ptr: *mut u8) -> Box<dyn Any + Send> {
     intrinsics::abort()
 }
diff --git a/src/libpanic_unwind/emcc.rs b/src/libpanic_unwind/emcc.rs
index 873135414bd9d..e541ec3002510 100644
--- a/src/libpanic_unwind/emcc.rs
+++ b/src/libpanic_unwind/emcc.rs
@@ -48,8 +48,6 @@ static EXCEPTION_TYPE_INFO: TypeInfo = TypeInfo {
     name: b"rust_panic\0".as_ptr(),
 };
 
-pub type Payload = *mut u8;
-
 struct Exception {
     // This needs to be an Option because the object's lifetime follows C++
     // semantics: when catch_unwind moves the Box out of the exception it must
diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs
index dd84a814f48b1..20ae5edaa2a69 100644
--- a/src/libpanic_unwind/gcc.rs
+++ b/src/libpanic_unwind/gcc.rs
@@ -82,8 +82,6 @@ pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
     }
 }
 
-pub type Payload = *mut u8;
-
 pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
     let exception = Box::from_raw(ptr as *mut Exception);
     exception.cause
diff --git a/src/libpanic_unwind/hermit.rs b/src/libpanic_unwind/hermit.rs
index 8ffb4bcd3df23..6bded4dd499bd 100644
--- a/src/libpanic_unwind/hermit.rs
+++ b/src/libpanic_unwind/hermit.rs
@@ -6,8 +6,6 @@ use alloc::boxed::Box;
 use core::any::Any;
 use core::ptr;
 
-pub type Payload = *mut u8;
-
 pub unsafe fn cleanup(_ptr: *mut u8) -> Box<dyn Any + Send> {
     extern "C" {
         pub fn __rust_abort() -> !;
diff --git a/src/libpanic_unwind/lib.rs b/src/libpanic_unwind/lib.rs
index ad82f22510c41..87d24841d04a3 100644
--- a/src/libpanic_unwind/lib.rs
+++ b/src/libpanic_unwind/lib.rs
@@ -35,8 +35,8 @@ use alloc::boxed::Box;
 use core::any::Any;
 use core::panic::BoxMeUp;
 
-// If adding to this list, you should also look at libstd::panicking's identical
-// list of Payload types and likely add to there as well.
+// If adding to this list, you should also look at the list of TryPayload types
+// defined in payload.rs and likely add to there as well.
 cfg_if::cfg_if! {
     if #[cfg(target_os = "emscripten")] {
         #[path = "emcc.rs"]
@@ -62,6 +62,8 @@ cfg_if::cfg_if! {
     }
 }
 
+include!("payload.rs");
+
 extern "C" {
     /// Handler in libstd called when a panic object is dropped outside of
     /// `catch_unwind`.
@@ -71,9 +73,9 @@ extern "C" {
 mod dwarf;
 
 #[no_mangle]
-pub unsafe extern "C" fn __rust_panic_cleanup(payload: *mut u8) -> *mut (dyn Any + Send + 'static) {
-    let payload = payload as *mut imp::Payload;
-    let payload = *(payload);
+pub unsafe extern "C" fn __rust_panic_cleanup(
+    payload: TryPayload,
+) -> *mut (dyn Any + Send + 'static) {
     Box::into_raw(imp::cleanup(payload))
 }
 
diff --git a/src/libpanic_unwind/payload.rs b/src/libpanic_unwind/payload.rs
new file mode 100644
index 0000000000000..1234db7da0f08
--- /dev/null
+++ b/src/libpanic_unwind/payload.rs
@@ -0,0 +1,21 @@
+// Type definition for the payload argument of the try intrinsic.
+//
+// This must be kept in sync with the implementations of the try intrinsic.
+//
+// This file is included by both panic runtimes and libstd. It is part of the
+// panic runtime ABI.
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "emscripten")] {
+        type TryPayload = *mut u8;
+    } else if #[cfg(target_arch = "wasm32")] {
+        type TryPayload = *mut u8;
+    } else if #[cfg(target_os = "hermit")] {
+        type TryPayload = *mut u8;
+    } else if #[cfg(all(target_env = "msvc", target_arch = "aarch64"))] {
+        type TryPayload = *mut u8;
+    } else if #[cfg(target_env = "msvc")] {
+        type TryPayload = [u64; 2];
+    } else {
+        type TryPayload = *mut u8;
+    }
+}
diff --git a/src/libpanic_unwind/seh.rs b/src/libpanic_unwind/seh.rs
index 6f464c1ab680e..da5ee5369e082 100644
--- a/src/libpanic_unwind/seh.rs
+++ b/src/libpanic_unwind/seh.rs
@@ -308,8 +308,6 @@ pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
     _CxxThrowException(throw_ptr, &mut THROW_INFO as *mut _ as *mut _);
 }
 
-pub type Payload = [u64; 2];
-
 pub unsafe fn cleanup(payload: [u64; 2]) -> Box<dyn Any + Send> {
     mem::transmute(raw::TraitObject { data: payload[0] as *mut _, vtable: payload[1] as *mut _ })
 }
diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs
index b02cedd5da5bf..38cb4418dd036 100644
--- a/src/libstd/panicking.rs
+++ b/src/libstd/panicking.rs
@@ -28,30 +28,8 @@ use crate::io::set_panic;
 #[cfg(test)]
 use realstd::io::set_panic;
 
-// This must be kept in sync with the implementations in libpanic_unwind.
-//
-// This is *not* checked in anyway; the compiler does not allow us to use a
-// type/macro/anything from panic_unwind, since we're then linking in the
-// panic_unwind runtime even during -Cpanic=abort.
-//
-// Essentially this must be the type of `imp::Payload` in libpanic_unwind.
-cfg_if::cfg_if! {
-    if #[cfg(not(feature = "panic_unwind"))] {
-        type Payload = ();
-    } else if #[cfg(target_os = "emscripten")] {
-        type Payload = *mut u8;
-    } else if #[cfg(target_arch = "wasm32")] {
-        type Payload = *mut u8;
-    } else if #[cfg(target_os = "hermit")] {
-        type Payload = *mut u8;
-    } else if #[cfg(all(target_env = "msvc", target_arch = "aarch64"))] {
-        type Payload = *mut u8;
-    } else if #[cfg(target_env = "msvc")] {
-        type Payload = [u64; 2];
-    } else {
-        type Payload = *mut u8;
-    }
-}
+// Include the definition of UnwindPayload from libpanic_unwind.
+include!("../libpanic_unwind/payload.rs");
 
 // Binary interface to the panic runtime that the standard library depends on.
 //
@@ -67,7 +45,7 @@ cfg_if::cfg_if! {
 extern "C" {
     /// The payload ptr here is actually the same as the payload ptr for the try
     /// intrinsic (i.e., is really `*mut [u64; 2]` or `*mut *mut u8`).
-    fn __rust_panic_cleanup(payload: *mut u8) -> *mut (dyn Any + Send + 'static);
+    fn __rust_panic_cleanup(payload: TryPayload) -> *mut (dyn Any + Send + 'static);
 
     /// `payload` is actually a `*mut &mut dyn BoxMeUp` but that would cause FFI warnings.
     /// It cannot be `Box<dyn BoxMeUp>` because the other end of this call does not depend
@@ -297,7 +275,7 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
     // method of calling a catch panic whilst juggling ownership.
     let mut data = Data { f: ManuallyDrop::new(f) };
 
-    let mut payload: MaybeUninit<Payload> = MaybeUninit::uninit();
+    let mut payload: MaybeUninit<TryPayload> = MaybeUninit::uninit();
 
     let data_ptr = &mut data as *mut _ as *mut u8;
     let payload_ptr = payload.as_mut_ptr() as *mut _;
@@ -312,8 +290,8 @@ pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>>
     // optimizer (in most cases this function is not inlined even as a normal,
     // non-cold function, though, as of the writing of this comment).
     #[cold]
-    unsafe fn cleanup(mut payload: Payload) -> Box<dyn Any + Send + 'static> {
-        let obj = Box::from_raw(__rust_panic_cleanup(&mut payload as *mut _ as *mut u8));
+    unsafe fn cleanup(payload: TryPayload) -> Box<dyn Any + Send + 'static> {
+        let obj = Box::from_raw(__rust_panic_cleanup(payload));
         update_panic_count(-1);
         obj
     }
diff --git a/src/test/ui/no-landing-pads.rs b/src/test/ui/no-landing-pads.rs
deleted file mode 100644
index 44af25f7f8f48..0000000000000
--- a/src/test/ui/no-landing-pads.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// run-pass
-// compile-flags: -Z no-landing-pads -C codegen-units=1
-// ignore-emscripten no threads support
-// ignore-test fails because catch_unwind doesn't work with no-landing-pads
-
-use std::thread;
-
-static mut HIT: bool = false;
-
-struct A;
-
-impl Drop for A {
-    fn drop(&mut self) {
-        unsafe { HIT = true; }
-    }
-}
-
-fn main() {
-    thread::spawn(move|| -> () {
-        let _a = A;
-        panic!();
-    }).join().unwrap_err();
-    assert!(unsafe { !HIT });
-}

From bf2c05aaea2c7453f710ad47d55aaeb9ec32cddf Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Mon, 13 Jan 2020 00:55:36 +0000
Subject: [PATCH 09/21] Fix cross-DLL panics under MSVC

---
 .../src/language-features/lang-items.md       |  1 -
 src/libpanic_unwind/seh.rs                    | 13 ++++----
 src/librustc_codegen_llvm/intrinsic.rs        | 30 +++++++++++++++----
 3 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/src/doc/unstable-book/src/language-features/lang-items.md b/src/doc/unstable-book/src/language-features/lang-items.md
index 6f096e582f575..b6e61e7050cea 100644
--- a/src/doc/unstable-book/src/language-features/lang-items.md
+++ b/src/doc/unstable-book/src/language-features/lang-items.md
@@ -248,7 +248,6 @@ the source code.
   - `eh_personality`: `libpanic_unwind/gcc.rs` (GNU)
   - `eh_personality`: `libpanic_unwind/seh.rs` (SEH)
   - `eh_unwind_resume`: `libpanic_unwind/gcc.rs` (GCC)
-  - `eh_catch_typeinfo`: `libpanic_unwind/seh.rs` (SEH)
   - `eh_catch_typeinfo`: `libpanic_unwind/emcc.rs` (EMCC)
   - `panic`: `libcore/panicking.rs`
   - `panic_bounds_check`: `libcore/panicking.rs`
diff --git a/src/libpanic_unwind/seh.rs b/src/libpanic_unwind/seh.rs
index da5ee5369e082..f599f9815a62c 100644
--- a/src/libpanic_unwind/seh.rs
+++ b/src/libpanic_unwind/seh.rs
@@ -167,6 +167,9 @@ pub struct _TypeDescriptor {
 
 // Note that we intentionally ignore name mangling rules here: we don't want C++
 // to be able to catch Rust panics by simply declaring a `struct rust_panic`.
+//
+// When modifying, make sure that the type name string exactly matches
+// the one used in src/librustc_codegen_llvm/intrinsic.rs.
 const TYPE_NAME: [u8; 11] = *b"rust_panic\0";
 
 static mut THROW_INFO: _ThrowInfo = _ThrowInfo {
@@ -199,12 +202,12 @@ extern "C" {
     static TYPE_INFO_VTABLE: *const u8;
 }
 
-// We use #[lang = "eh_catch_typeinfo"] here as this is the type descriptor which
-// we'll use in LLVM's `catchpad` instruction which ends up also being passed as
-// an argument to the C++ personality function.
+// This type descriptor is only used when throwing an exception. The catch part
+// is handled by the try intrinsic, which generates its own TypeDescriptor.
 //
-// Again, I'm not entirely sure what this is describing, it just seems to work.
-#[cfg_attr(not(test), lang = "eh_catch_typeinfo")]
+// This is fine since the MSVC runtime uses string comparison on the type name
+// to match TypeDescriptors rather than pointer equality.
+#[cfg_attr(bootstrap, lang = "eh_catch_typeinfo")]
 static mut TYPE_DESCRIPTOR: _TypeDescriptor = _TypeDescriptor {
     pVFTable: unsafe { &TYPE_INFO_VTABLE } as *const _ as *const _,
     spare: core::ptr::null_mut(),
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
index 32f0154fa50bf..d147a40d6679f 100644
--- a/src/librustc_codegen_llvm/intrinsic.rs
+++ b/src/librustc_codegen_llvm/intrinsic.rs
@@ -954,6 +954,31 @@ fn codegen_msvc_try(
         let cs = catchswitch.catch_switch(None, None, 1);
         catchswitch.add_handler(cs, catchpad.llbb());
 
+        // We can't use the TypeDescriptor defined in libpanic_unwind because it
+        // might be in another DLL and the SEH encoding only supports specifying
+        // a TypeDescriptor from the current module.
+        //
+        // However this isn't an issue since the MSVC runtime uses string
+        // comparison on the type name to match TypeDescriptors rather than
+        // pointer equality.
+        //
+        // So instead we generate a new TypeDescriptor in each module that uses
+        // `try` and let the linker merge duplicate definitions in the same
+        // module.
+        //
+        // When modifying, make sure that the type_name string exactly matches
+        // the one used in src/libpanic_unwind/seh.rs.
+        let type_info_vtable = bx.declare_global("??_7type_info@@6B@", bx.type_i8p());
+        let type_name = bx.const_bytes(b"rust_panic\0");
+        let type_info =
+            bx.const_struct(&[type_info_vtable, bx.const_null(bx.type_i8p()), type_name], false);
+        let tydesc = bx.declare_global("__rust_panic_type_info", bx.val_ty(type_info));
+        unsafe {
+            llvm::LLVMRustSetLinkage(tydesc, llvm::Linkage::LinkOnceODRLinkage);
+            llvm::SetUniqueComdat(bx.llmod, tydesc);
+            llvm::LLVMSetInitializer(tydesc, type_info);
+        }
+
         // The flag value of 8 indicates that we are catching the exception by
         // reference instead of by value. We can't use catch by value because
         // that requires copying the exception object, which we don't support
@@ -961,12 +986,7 @@ fn codegen_msvc_try(
         //
         // Source: MicrosoftCXXABI::getAddrOfCXXCatchHandlerType in clang
         let flags = bx.const_i32(8);
-        let tydesc = match bx.tcx().lang_items().eh_catch_typeinfo() {
-            Some(did) => bx.get_static(did),
-            None => bug!("eh_catch_typeinfo not defined, but needed for SEH unwinding"),
-        };
         let funclet = catchpad.catch_pad(cs, &[tydesc, flags, slot]);
-
         let i64_align = bx.tcx().data_layout.i64_align.abi;
         let payload_ptr = catchpad.load(slot, ptr_align);
         let payload = catchpad.load(payload_ptr, i64_align);

From a3731a24816f8ce0c4011d20a20ef01bb28d33f5 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Tue, 14 Jan 2020 17:42:47 +0000
Subject: [PATCH 10/21] Apply CPU attributes to __rust_try

---
 src/librustc_codegen_llvm/intrinsic.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
index d147a40d6679f..8b9a96294ced1 100644
--- a/src/librustc_codegen_llvm/intrinsic.rs
+++ b/src/librustc_codegen_llvm/intrinsic.rs
@@ -1106,6 +1106,8 @@ fn gen_fn<'ll, 'tcx>(
     ));
     let fn_abi = FnAbi::of_fn_ptr(cx, rust_fn_sig, &[]);
     let llfn = cx.declare_fn(name, &fn_abi);
+    cx.set_frame_pointer_elimination(llfn);
+    cx.apply_target_cpu_attr(llfn);
     // FIXME(eddyb) find a nicer way to do this.
     unsafe { llvm::LLVMRustSetLinkage(llfn, llvm::Linkage::InternalLinkage) };
     let bx = Builder::new_block(cx, llfn, "entry-block");

From 537ca394787be2a2ac3eb85d5d823cdb5d2a17b6 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Wed, 22 Jan 2020 18:03:59 -0500
Subject: [PATCH 11/21] [DO NOT MERGE] enable mingw builder on try

---
 src/ci/azure-pipelines/try.yml | 34 ++++++++++++----------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/src/ci/azure-pipelines/try.yml b/src/ci/azure-pipelines/try.yml
index f8ddf0eb46cfd..1a1e963bc9a5a 100644
--- a/src/ci/azure-pipelines/try.yml
+++ b/src/ci/azure-pipelines/try.yml
@@ -49,25 +49,15 @@ jobs:
 #         NO_LLVM_ASSERTIONS: 1
 #         NO_DEBUG_ASSERTIONS: 1
 #
-# - job: Windows
-#   timeoutInMinutes: 600
-#   pool:
-#     vmImage: 'vs2017-win2016'
-#   steps:
-#   - template: steps/run.yml
-#   strategy:
-#     matrix:
-#       dist-x86_64-msvc:
-#         RUST_CONFIGURE_ARGS: >
-#           --build=x86_64-pc-windows-msvc
-#           --target=x86_64-pc-windows-msvc,aarch64-pc-windows-msvc
-#           --enable-full-tools
-#           --enable-profiler
-#         SCRIPT: python x.py dist
-#         DIST_REQUIRE_ALL_TOOLS: 1
-#         DEPLOY: 1
-#
-#       dist-x86_64-msvc-alt:
-#         RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended --enable-profiler
-#         SCRIPT: python x.py dist
-#         DEPLOY_ALT: 1
+- job: Windows
+  timeoutInMinutes: 600
+  pool:
+    vmImage: 'vs2017-win2016'
+  steps:
+  - template: steps/run.yml
+  strategy:
+    matrix:
+      i686-mingw-2:
+        RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu
+        SCRIPT: make ci-mingw-subset-2
+        CUSTOM_MINGW: 1

From a67775510a7d338600b596c2fd911b7207f226a5 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Fri, 24 Jan 2020 09:21:05 -0500
Subject: [PATCH 12/21] Also distribute mingw

---
 src/ci/azure-pipelines/try.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/ci/azure-pipelines/try.yml b/src/ci/azure-pipelines/try.yml
index 1a1e963bc9a5a..e0199c1409e06 100644
--- a/src/ci/azure-pipelines/try.yml
+++ b/src/ci/azure-pipelines/try.yml
@@ -61,3 +61,8 @@ jobs:
         RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu
         SCRIPT: make ci-mingw-subset-2
         CUSTOM_MINGW: 1
+      dist-i686-mingw:
+        RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-full-tools --enable-profiler
+        SCRIPT: python x.py dist
+        CUSTOM_MINGW: 1
+        DIST_REQUIRE_ALL_TOOLS: 1

From a66a223a60bbc4813239d6a56344fef409094fb1 Mon Sep 17 00:00:00 2001
From: Mark Rousskov <mark.simulacrum@gmail.com>
Date: Sat, 25 Jan 2020 09:49:29 -0500
Subject: [PATCH 13/21] Enable debug information

---
 src/ci/azure-pipelines/try.yml | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/ci/azure-pipelines/try.yml b/src/ci/azure-pipelines/try.yml
index e0199c1409e06..2452f80884c74 100644
--- a/src/ci/azure-pipelines/try.yml
+++ b/src/ci/azure-pipelines/try.yml
@@ -6,17 +6,17 @@ variables:
 - group: prod-credentials
 
 jobs:
-- job: Linux
-  timeoutInMinutes: 600
-  pool:
-    vmImage: ubuntu-16.04
-  steps:
-  - template: steps/run.yml
-  strategy:
-    matrix:
-      dist-x86_64-linux: {}
-      dist-x86_64-linux-alt:
-        IMAGE: dist-x86_64-linux
+    # - job: Linux
+    #   timeoutInMinutes: 600
+    #   pool:
+    #     vmImage: ubuntu-16.04
+    #   steps:
+    #   - template: steps/run.yml
+    #   strategy:
+    #     matrix:
+    #       dist-x86_64-linux: {}
+    #       dist-x86_64-linux-alt:
+    #         IMAGE: dist-x86_64-linux
 
 # The macOS and Windows builds here are currently disabled due to them not being
 # overly necessary on `try` builds. We also don't actually have anything that
@@ -62,7 +62,7 @@ jobs:
         SCRIPT: make ci-mingw-subset-2
         CUSTOM_MINGW: 1
       dist-i686-mingw:
-        RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-full-tools --enable-profiler
+        RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-debug-assertions --enable-optimize --debuginfo-level=1
         SCRIPT: python x.py dist
         CUSTOM_MINGW: 1
-        DIST_REQUIRE_ALL_TOOLS: 1
+        N_DIST_REQUIRE_ALL_TOOLS: 1

From 105b88227f96193c276747f141ee2e932cdf9c13 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Mon, 27 Jan 2020 06:10:10 +0000
Subject: [PATCH 14/21] Implement rust_eh_unwind_resume as a naked function

---
 src/libpanic_unwind/gcc.rs | 9 +++++++--
 src/libpanic_unwind/lib.rs | 2 ++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs
index 20ae5edaa2a69..214e1fc98e785 100644
--- a/src/libpanic_unwind/gcc.rs
+++ b/src/libpanic_unwind/gcc.rs
@@ -332,8 +332,13 @@ unsafe fn find_eh_action(
 ))]
 #[lang = "eh_unwind_resume"]
 #[unwind(allowed)]
-unsafe extern "C" fn rust_eh_unwind_resume(panic_ctx: *mut u8) -> ! {
-    uw::_Unwind_Resume(panic_ctx as *mut uw::_Unwind_Exception);
+#[naked]
+unsafe extern "C" fn rust_eh_unwind_resume(_panic_ctx: *mut u8) -> ! {
+    // This needs to be a naked function because _Unwind_Resume expects to be
+    // called directly from the landing pad. This means that we need to force
+    // a tail call here.
+    asm!("jmp ${0:P}" :: "s" (uw::_Unwind_Resume as usize) :: "volatile");
+    core::hint::unreachable_unchecked();
 }
 
 // Frame unwind info registration
diff --git a/src/libpanic_unwind/lib.rs b/src/libpanic_unwind/lib.rs
index 87d24841d04a3..14f29f2697279 100644
--- a/src/libpanic_unwind/lib.rs
+++ b/src/libpanic_unwind/lib.rs
@@ -28,6 +28,8 @@
 #![feature(abi_thiscall)]
 #![feature(rustc_attrs)]
 #![feature(raw)]
+#![feature(asm)]
+#![feature(naked_functions)]
 #![panic_runtime]
 #![feature(panic_runtime)]
 

From 22e38c89ba38b87c268565570895f0e8eec0c195 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Mon, 27 Jan 2020 13:48:40 +0000
Subject: [PATCH 15/21] Hack to make naked functions with arguments work

---
 src/librustc_codegen_ssa/mir/mod.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/librustc_codegen_ssa/mir/mod.rs b/src/librustc_codegen_ssa/mir/mod.rs
index 64ead19b35869..26b41bdc19e97 100644
--- a/src/librustc_codegen_ssa/mir/mod.rs
+++ b/src/librustc_codegen_ssa/mir/mod.rs
@@ -1,5 +1,6 @@
 use crate::base;
 use crate::traits::*;
+use rustc::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc::mir;
 use rustc::ty::layout::{FnAbiExt, HasTyCtxt, TyLayout};
 use rustc::ty::{self, Instance, Ty, TypeFoldable};
@@ -334,6 +335,7 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     let mir = fx.mir;
     let mut idx = 0;
     let mut llarg_idx = fx.fn_abi.ret.is_indirect() as usize;
+    let codegen_fn_attrs = fx.cx.tcx().codegen_fn_attrs(fx.instance.def_id());
 
     let args = mir
         .args_iter()
@@ -341,6 +343,17 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         .map(|(arg_index, local)| {
             let arg_decl = &mir.local_decls[local];
 
+            // Naked functions can't contain an alloca. This is a horrible hack,
+            // but at least it makes naked functions with arguments work
+            // correctly in debug build (they won't corrupt the stack any more).
+            if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
+                let layout = bx.layout_of(arg_decl.ty);
+                return LocalRef::Place(PlaceRef::new_sized(
+                    bx.const_undef(bx.cx().backend_type(layout)),
+                    layout,
+                ));
+            }
+
             if Some(local) == mir.spread_arg {
                 // This argument (e.g., the last argument in the "rust-call" ABI)
                 // is a tuple that was spread at the ABI level and now we have

From 593426d9b33296f41e60f09110a6bb1c5f5773a4 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Mon, 27 Jan 2020 16:36:58 +0000
Subject: [PATCH 16/21] [DO NOT MERGE] ignore test

---
 src/test/codegen/naked-functions.rs | 86 -----------------------------
 1 file changed, 86 deletions(-)
 delete mode 100644 src/test/codegen/naked-functions.rs

diff --git a/src/test/codegen/naked-functions.rs b/src/test/codegen/naked-functions.rs
deleted file mode 100644
index 493c1b9f0ba6b..0000000000000
--- a/src/test/codegen/naked-functions.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-// compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(naked_functions)]
-
-// CHECK: Function Attrs: naked
-// CHECK-NEXT: define void @naked_empty()
-#[no_mangle]
-#[naked]
-pub fn naked_empty() {
-    // CHECK-NEXT: {{.+}}:
-    // CHECK-NEXT: ret void
-}
-
-// CHECK: Function Attrs: naked
-#[no_mangle]
-#[naked]
-// CHECK-NEXT: define void @naked_with_args(i{{[0-9]+( %0)?}})
-pub fn naked_with_args(a: isize) {
-    // CHECK-NEXT: {{.+}}:
-    // CHECK-NEXT: %a = alloca i{{[0-9]+}}
-    &a; // keep variable in an alloca
-    // CHECK: ret void
-}
-
-// CHECK: Function Attrs: naked
-// CHECK-NEXT: define i{{[0-9]+}} @naked_with_return()
-#[no_mangle]
-#[naked]
-pub fn naked_with_return() -> isize {
-    // CHECK-NEXT: {{.+}}:
-    // CHECK-NEXT: ret i{{[0-9]+}} 0
-    0
-}
-
-// CHECK: Function Attrs: naked
-// CHECK-NEXT: define i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+( %0)?}})
-#[no_mangle]
-#[naked]
-pub fn naked_with_args_and_return(a: isize) -> isize {
-    // CHECK-NEXT: {{.+}}:
-    // CHECK-NEXT: %a = alloca i{{[0-9]+}}
-    &a; // keep variable in an alloca
-    // CHECK: ret i{{[0-9]+}} %{{[0-9]+}}
-    a
-}
-
-// CHECK: Function Attrs: naked
-// CHECK-NEXT: define void @naked_recursive()
-#[no_mangle]
-#[naked]
-pub fn naked_recursive() {
-    // CHECK-NEXT: {{.+}}:
-    // CHECK-NEXT: call void @naked_empty()
-
-    // FIXME(#39685) Avoid one block per call.
-    // CHECK-NEXT: br label %bb1
-    // CHECK: bb1:
-
-    naked_empty();
-
-    // CHECK-NEXT: %_4 = call i{{[0-9]+}} @naked_with_return()
-
-    // FIXME(#39685) Avoid one block per call.
-    // CHECK-NEXT: br label %bb2
-    // CHECK: bb2:
-
-    // CHECK-NEXT: %_3 = call i{{[0-9]+}} @naked_with_args_and_return(i{{[0-9]+}} %_4)
-
-    // FIXME(#39685) Avoid one block per call.
-    // CHECK-NEXT: br label %bb3
-    // CHECK: bb3:
-
-    // CHECK-NEXT: call void @naked_with_args(i{{[0-9]+}} %_3)
-
-    // FIXME(#39685) Avoid one block per call.
-    // CHECK-NEXT: br label %bb4
-    // CHECK: bb4:
-
-    naked_with_args(
-        naked_with_args_and_return(
-            naked_with_return()
-        )
-    );
-    // CHECK-NEXT: ret void
-}

From 176f4be250a7abe08cadd18dda3584c234a6c474 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Tue, 28 Jan 2020 04:16:38 +0000
Subject: [PATCH 17/21] Never inline naked functions

---
 src/librustc_codegen_llvm/attributes.rs | 28 ++++++++++++++-----------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/librustc_codegen_llvm/attributes.rs b/src/librustc_codegen_llvm/attributes.rs
index a9e4fdba03036..7b019b0357c1f 100644
--- a/src/librustc_codegen_llvm/attributes.rs
+++ b/src/librustc_codegen_llvm/attributes.rs
@@ -270,12 +270,23 @@ pub fn from_fn_attrs(
         }
     }
 
-    // FIXME(eddyb) consolidate these two `inline` calls (and avoid overwrites).
-    if instance.def.requires_inline(cx.tcx) {
-        inline(cx, llfn, attributes::InlineAttr::Hint);
-    }
+    // Naked functions must never be inlined and must not contain any prologue
+    // or epilogue.
+    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
+        naked(llfn, true);
+        inline(cx, llfn, attributes::InlineAttr::Never);
+    } else {
+        set_frame_pointer_elimination(cx, llfn);
+        set_instrument_function(cx, llfn);
+        set_probestack(cx, llfn);
 
-    inline(cx, llfn, codegen_fn_attrs.inline);
+        // FIXME(eddyb) consolidate these two `inline` calls (and avoid overwrites).
+        if instance.def.requires_inline(cx.tcx) {
+            inline(cx, llfn, attributes::InlineAttr::Hint);
+        }
+
+        inline(cx, llfn, codegen_fn_attrs.inline);
+    }
 
     // The `uwtable` attribute according to LLVM is:
     //
@@ -297,19 +308,12 @@ pub fn from_fn_attrs(
         attributes::emit_uwtable(llfn, true);
     }
 
-    set_frame_pointer_elimination(cx, llfn);
-    set_instrument_function(cx, llfn);
-    set_probestack(cx, llfn);
-
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::COLD) {
         Attribute::Cold.apply_llfn(Function, llfn);
     }
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_RETURNS_TWICE) {
         Attribute::ReturnsTwice.apply_llfn(Function, llfn);
     }
-    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
-        naked(llfn, true);
-    }
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::ALLOCATOR) {
         Attribute::NoAlias.apply_llfn(llvm::AttributePlace::ReturnValue, llfn);
     }

From 845bcdd2372182dbc59632e516a729726fb7d0f5 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Tue, 28 Jan 2020 12:30:57 +0000
Subject: [PATCH 18/21] Mark rust_eh_unwind_resume as #[inline(never)] for
 stage0

---
 src/libpanic_unwind/gcc.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs
index 214e1fc98e785..290ced470e61d 100644
--- a/src/libpanic_unwind/gcc.rs
+++ b/src/libpanic_unwind/gcc.rs
@@ -333,6 +333,7 @@ unsafe fn find_eh_action(
 #[lang = "eh_unwind_resume"]
 #[unwind(allowed)]
 #[naked]
+#[inline(never)]
 unsafe extern "C" fn rust_eh_unwind_resume(_panic_ctx: *mut u8) -> ! {
     // This needs to be a naked function because _Unwind_Resume expects to be
     // called directly from the landing pad. This means that we need to force

From d1936887cd06cfb5a1416d1b09ddc87716dc8136 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Fri, 28 Feb 2020 18:57:19 +0000
Subject: [PATCH 19/21] Use hacked llvm which uses rust_eh_unwind_resume
 instead of _Unwind_Resume

---
 .gitmodules      | 4 ++--
 src/llvm-project | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 003e50d0788e4..aa24426e13538 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -39,8 +39,8 @@
 	url = https://github.com/rust-lang/edition-guide.git
 [submodule "src/llvm-project"]
 	path = src/llvm-project
-	url = https://github.com/rust-lang/llvm-project.git
-	branch = rustc/9.0-2019-12-19
+	url = https://github.com/Amanieu/llvm-project.git
+	branch = opt-catch
 [submodule "src/doc/embedded-book"]
 	path = src/doc/embedded-book
 	url = https://github.com/rust-embedded/book.git
diff --git a/src/llvm-project b/src/llvm-project
index 9f65ad057357b..dd3864293a5ba 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 9f65ad057357b307180955831968f79e74090a90
+Subproject commit dd3864293a5ba9123ee12983018ffafac9d16c78

From bc314ab8a7cd99c54e03e15c361dcd7308ebc897 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Fri, 28 Feb 2020 18:58:50 +0000
Subject: [PATCH 20/21] Disable custom_unwind_resume on Windows

---
 src/librustc_target/spec/windows_base.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustc_target/spec/windows_base.rs b/src/librustc_target/spec/windows_base.rs
index 693a343d5a5fb..98449ccb85e5e 100644
--- a/src/librustc_target/spec/windows_base.rs
+++ b/src/librustc_target/spec/windows_base.rs
@@ -64,7 +64,7 @@ pub fn opts() -> TargetOptions {
         ],
         late_link_args,
         post_link_objects: vec!["rsend.o".to_string()],
-        custom_unwind_resume: true,
+        custom_unwind_resume: false,
         abi_return_struct_as_int: true,
         emit_debug_gdb_scripts: false,
         requires_uwtable: true,

From 9bcdc065f0d80e47ea9f571f5f17fb20aa550df5 Mon Sep 17 00:00:00 2001
From: Amanieu d'Antras <amanieu@gmail.com>
Date: Fri, 28 Feb 2020 23:13:36 +0000
Subject: [PATCH 21/21] Use a global_asm! instead of a naked function

---
 src/libpanic_unwind/gcc.rs | 32 ++++++++++++++++++++++++--------
 src/libpanic_unwind/lib.rs |  1 +
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs
index 290ced470e61d..6cea4907a3fb5 100644
--- a/src/libpanic_unwind/gcc.rs
+++ b/src/libpanic_unwind/gcc.rs
@@ -326,22 +326,38 @@ unsafe fn find_eh_action(
 
 // See docs in the `unwind` module.
 #[cfg(all(
+    not(bootstrap),
+    target_os = "windows",
+    any(target_arch = "x86", target_arch = "x86_64"),
+    target_env = "gnu"
+))]
+global_asm! {
+    r#"
+    .def _rust_eh_unwind_resume;
+    .scl 2;
+    .type 32;
+    .endef
+    .globl _rust_eh_unwind_resume
+    .p2align 4, 0x90
+_rust_eh_unwind_resume:
+    .cfi_startproc
+    jmp __Unwind_Resume
+    .cfi_endproc
+    "#
+}
+#[cfg(all(
+    bootstrap,
     target_os = "windows",
     any(target_arch = "x86", target_arch = "x86_64"),
     target_env = "gnu"
 ))]
 #[lang = "eh_unwind_resume"]
 #[unwind(allowed)]
-#[naked]
-#[inline(never)]
-unsafe extern "C" fn rust_eh_unwind_resume(_panic_ctx: *mut u8) -> ! {
-    // This needs to be a naked function because _Unwind_Resume expects to be
-    // called directly from the landing pad. This means that we need to force
-    // a tail call here.
-    asm!("jmp ${0:P}" :: "s" (uw::_Unwind_Resume as usize) :: "volatile");
-    core::hint::unreachable_unchecked();
+unsafe extern "C" fn rust_eh_unwind_resume(panic_ctx: *mut u8) -> ! {
+    uw::_Unwind_Resume(panic_ctx as *mut uw::_Unwind_Exception);
 }
 
+
 // Frame unwind info registration
 //
 // Each module's image contains a frame unwind info section (usually
diff --git a/src/libpanic_unwind/lib.rs b/src/libpanic_unwind/lib.rs
index 14f29f2697279..686282f966460 100644
--- a/src/libpanic_unwind/lib.rs
+++ b/src/libpanic_unwind/lib.rs
@@ -32,6 +32,7 @@
 #![feature(naked_functions)]
 #![panic_runtime]
 #![feature(panic_runtime)]
+#![feature(global_asm)]
 
 use alloc::boxed::Box;
 use core::any::Any;