Auto merge of #32647 - Amanieu:checked_atomic_intrinsics, r=eddyb

Only allow using the atomic intrinsics on integer types

Using these with non-integer types results in LLVM asserts. Atomic operations on non-integer types will require values be transmuted into an integer type of suitable size.

This doesn't affect the standard library since `AtomicBool` and `AtomicPtr` currently use `usize` for atomic operations.

r? @eddyb

3 files changed, 161 insertions, 31 deletions

diff --git a/src/librustc_trans/intrinsic.rs b/src/librustc_trans/intrinsic.rs
index 219f970835a..28d5d9ac176 100644
--- a/src/librustc_trans/intrinsic.rs
+++ b/src/librustc_trans/intrinsic.rs
@@ -752,33 +752,47 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
 
             match split[1] {
                 "cxchg" | "cxchgweak" => {
-                    let cmp = from_immediate(bcx, llargs[1]);
-                    let src = from_immediate(bcx, llargs[2]);
-                    let ptr = PointerCast(bcx, llargs[0], val_ty(src).ptr_to());
-                    let weak = if split[1] == "cxchgweak" { llvm::True } else { llvm::False };
-                    let val = AtomicCmpXchg(bcx, ptr, cmp, src, order, failorder, weak);
-                    let result = ExtractValue(bcx, val, 0);
-                    let success = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool(bcx.ccx()));
-                    Store(bcx,
-                          result,
-                          PointerCast(bcx, StructGEP(bcx, llresult, 0), val_ty(src).ptr_to()));
-                    Store(bcx, success, StructGEP(bcx, llresult, 1));
+                    let sty = &substs.types.get(FnSpace, 0).sty;
+                    if int_type_width_signed(sty, ccx).is_some() {
+                        let weak = if split[1] == "cxchgweak" { llvm::True } else { llvm::False };
+                        let val = AtomicCmpXchg(bcx, llargs[0], llargs[1], llargs[2],
+                                                order, failorder, weak);
+                        let result = ExtractValue(bcx, val, 0);
+                        let success = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool(bcx.ccx()));
+                        Store(bcx, result, StructGEP(bcx, llresult, 0));
+                        Store(bcx, success, StructGEP(bcx, llresult, 1));
+                    } else {
+                        span_invalid_monomorphization_error(
+                            tcx.sess, span,
+                            &format!("invalid monomorphization of `{}` intrinsic: \
+                                      expected basic integer type, found `{}`", name, sty));
+                    }
                     C_nil(ccx)
                 }
 
                 "load" => {
-                    let tp_ty = *substs.types.get(FnSpace, 0);
-                    let mut ptr = llargs[0];
-                    if let Some(ty) = fn_ty.ret.cast {
-                        ptr = PointerCast(bcx, ptr, ty.ptr_to());
+                    let sty = &substs.types.get(FnSpace, 0).sty;
+                    if int_type_width_signed(sty, ccx).is_some() {
+                        AtomicLoad(bcx, llargs[0], order)
+                    } else {
+                        span_invalid_monomorphization_error(
+                            tcx.sess, span,
+                            &format!("invalid monomorphization of `{}` intrinsic: \
+                                      expected basic integer type, found `{}`", name, sty));
+                        C_nil(ccx)
                     }
-                    to_immediate(bcx, AtomicLoad(bcx, ptr, order), tp_ty)
                 }
 
                 "store" => {
-                    let val = from_immediate(bcx, llargs[1]);
-                    let ptr = PointerCast(bcx, llargs[0], val_ty(val).ptr_to());
-                    AtomicStore(bcx, val, ptr, order);
+                    let sty = &substs.types.get(FnSpace, 0).sty;
+                    if int_type_width_signed(sty, ccx).is_some() {
+                        AtomicStore(bcx, llargs[1], llargs[0], order);
+                    } else {
+                        span_invalid_monomorphization_error(
+                            tcx.sess, span,
+                            &format!("invalid monomorphization of `{}` intrinsic: \
+                                      expected basic integer type, found `{}`", name, sty));
+                    }
                     C_nil(ccx)
                 }
 
@@ -809,9 +823,16 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                         _ => ccx.sess().fatal("unknown atomic operation")
                     };
 
-                    let val = from_immediate(bcx, llargs[1]);
-                    let ptr = PointerCast(bcx, llargs[0], val_ty(val).ptr_to());
-                    AtomicRMW(bcx, atom_op, ptr, val, order)
+                    let sty = &substs.types.get(FnSpace, 0).sty;
+                    if int_type_width_signed(sty, ccx).is_some() {
+                        AtomicRMW(bcx, atom_op, llargs[0], llargs[1], order)
+                    } else {
+                        span_invalid_monomorphization_error(
+                            tcx.sess, span,
+                            &format!("invalid monomorphization of `{}` intrinsic: \
+                                      expected basic integer type, found `{}`", name, sty));
+                        C_nil(ccx)
+                    }
                 }
             }
 
diff --git a/src/test/compile-fail/non-interger-atomic.rs b/src/test/compile-fail/non-interger-atomic.rs
new file mode 100644
index 00000000000..d2376eecd9b
--- /dev/null
+++ b/src/test/compile-fail/non-interger-atomic.rs
@@ -0,0 +1,117 @@
+// Copyright 2016 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(core_intrinsics, rustc_attrs)]
+#![allow(warnings)]
+
+use std::intrinsics;
+
+#[derive(Copy, Clone)]
+struct Foo(i64);
+type Bar = &'static Fn();
+type Quux = [u8; 100];
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_bool_load(p: &mut bool, v: bool) {
+    intrinsics::atomic_load(p);
+    //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `bool`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_bool_store(p: &mut bool, v: bool) {
+    intrinsics::atomic_store(p, v);
+    //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `bool`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_bool_xchg(p: &mut bool, v: bool) {
+    intrinsics::atomic_xchg(p, v);
+    //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `bool`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_bool_cxchg(p: &mut bool, v: bool) {
+    intrinsics::atomic_cxchg(p, v, v);
+    //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `bool`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Foo_load(p: &mut Foo, v: Foo) {
+    intrinsics::atomic_load(p);
+    //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `Foo`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Foo_store(p: &mut Foo, v: Foo) {
+    intrinsics::atomic_store(p, v);
+    //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `Foo`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Foo_xchg(p: &mut Foo, v: Foo) {
+    intrinsics::atomic_xchg(p, v);
+    //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `Foo`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Foo_cxchg(p: &mut Foo, v: Foo) {
+    intrinsics::atomic_cxchg(p, v, v);
+    //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `Foo`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Bar_load(p: &mut Bar, v: Bar) {
+    intrinsics::atomic_load(p);
+    //~^ ERROR expected basic integer type, found `&'static std::ops::Fn() + 'static`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Bar_store(p: &mut Bar, v: Bar) {
+    intrinsics::atomic_store(p, v);
+    //~^ ERROR expected basic integer type, found `&'static std::ops::Fn() + 'static`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Bar_xchg(p: &mut Bar, v: Bar) {
+    intrinsics::atomic_xchg(p, v);
+    //~^ ERROR expected basic integer type, found `&'static std::ops::Fn() + 'static`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Bar_cxchg(p: &mut Bar, v: Bar) {
+    intrinsics::atomic_cxchg(p, v, v);
+    //~^ ERROR expected basic integer type, found `&'static std::ops::Fn() + 'static`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Quux_load(p: &mut Quux, v: Quux) {
+    intrinsics::atomic_load(p);
+    //~^ ERROR `atomic_load` intrinsic: expected basic integer type, found `[u8; 100]`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Quux_store(p: &mut Quux, v: Quux) {
+    intrinsics::atomic_store(p, v);
+    //~^ ERROR `atomic_store` intrinsic: expected basic integer type, found `[u8; 100]`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Quux_xchg(p: &mut Quux, v: Quux) {
+    intrinsics::atomic_xchg(p, v);
+    //~^ ERROR `atomic_xchg` intrinsic: expected basic integer type, found `[u8; 100]`
+}
+
+#[rustc_no_mir] // FIXME #27840 MIR doesn't provide precise spans for calls.
+unsafe fn test_Quux_cxchg(p: &mut Quux, v: Quux) {
+    intrinsics::atomic_cxchg(p, v, v);
+    //~^ ERROR `atomic_cxchg` intrinsic: expected basic integer type, found `[u8; 100]`
+}
+
+fn main() {}
diff --git a/src/test/run-pass/issue-23550.rs b/src/test/run-pass/issue-23550.rs
index 4b6d593f592..6e20662b702 100644
--- a/src/test/run-pass/issue-23550.rs
+++ b/src/test/run-pass/issue-23550.rs
@@ -16,24 +16,16 @@ use std::intrinsics;
 #[derive(Copy, Clone)]
 struct Wrap(i64);
 
-// These volatile and atomic intrinsics used to cause an ICE
+// These volatile intrinsics used to cause an ICE
 
 unsafe fn test_bool(p: &mut bool, v: bool) {
     intrinsics::volatile_load(p);
     intrinsics::volatile_store(p, v);
-    intrinsics::atomic_load(p);
-    intrinsics::atomic_cxchg(p, v, v);
-    intrinsics::atomic_store(p, v);
-    intrinsics::atomic_xchg(p, v);
 }
 
 unsafe fn test_immediate_fca(p: &mut Wrap, v: Wrap) {
     intrinsics::volatile_load(p);
     intrinsics::volatile_store(p, v);
-    intrinsics::atomic_load(p);
-    intrinsics::atomic_cxchg(p, v, v);
-    intrinsics::atomic_store(p, v);
-    intrinsics::atomic_xchg(p, v);
 }
 
 fn main() {}