Skip to content

Commit

Permalink
Auto merge of #32647 - Amanieu:checked_atomic_intrinsics, r=eddyb
Browse files Browse the repository at this point in the history
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
  • Loading branch information
bors committed Apr 4, 2016
2 parents 8d5e845 + 8620bba commit 600dc35
Show file tree
Hide file tree
Showing 3 changed files with 161 additions and 31 deletions.
65 changes: 43 additions & 22 deletions src/librustc_trans/intrinsic.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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)
}

Expand Down Expand Up @@ -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)
}
}
}

Expand Down
117 changes: 117 additions & 0 deletions src/test/compile-fail/non-interger-atomic.rs
Original file line number Diff line number Diff line change
@@ -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() {}
10 changes: 1 addition & 9 deletions src/test/run-pass/issue-23550.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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() {}

0 comments on commit 600dc35

Please sign in to comment.