From 78eae9bf23fc589d79ba402267b377f972140d19 Mon Sep 17 00:00:00 2001 From: Amanieu d'Antras Date: Thu, 31 Mar 2016 14:32:31 +0100 Subject: [PATCH 1/2] Only allow using the atomic intrinsics on integer types --- src/librustc_trans/intrinsic.rs | 65 +++++++++++++++++++++----------- src/test/run-pass/issue-23550.rs | 10 +---- 2 files changed, 44 insertions(+), 31 deletions(-) diff --git a/src/librustc_trans/intrinsic.rs b/src/librustc_trans/intrinsic.rs index 130a864f5e6ec..85c1ce9400c91 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/run-pass/issue-23550.rs b/src/test/run-pass/issue-23550.rs index 4b6d593f592d9..6e20662b702a9 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() {} From 8620bbaafd8bffda3584b4e8534d38dcc09cc6b1 Mon Sep 17 00:00:00 2001 From: Amanieu d'Antras Date: Thu, 31 Mar 2016 15:28:12 +0100 Subject: [PATCH 2/2] Add compile-fail test --- src/test/compile-fail/non-interger-atomic.rs | 117 +++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 src/test/compile-fail/non-interger-atomic.rs 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 0000000000000..d2376eecd9b50 --- /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 or the MIT license +// , 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() {}