bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #57021 - nikic:arg-pointer-align, r=nagisa

Browse source 
Enable emission of alignment attrs for pointer params

Instead disable creation of assumptions during inlining using an LLVM opt flag. For non-inlined functions, this gives us alignment information, while not inserting any assumes that kill other optimizations.

The `-Z arg-align-attributes` option which previously controlled this behavior is removed.

Fixes #54982.

r? @nagisa

cc @eddyb who added the current behavior, and @scottmcm, who added the `-Z arg-align-attributes` flag.
This commit is contained in:
Mazdak Farrokhzad 2018-12-24 13:29:35 +01:00 • committed by GitHub
commit c44bb0230e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 20 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/session/config.rs
View file

@ -1271,8 +1271,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
"set the MIR optimization level (0-3, default: 1)"), "set the MIR optimization level (0-3, default: 1)"),
mutable_noalias: Option<bool> = (None, parse_opt_bool, [TRACKED], mutable_noalias: Option<bool> = (None, parse_opt_bool, [TRACKED],
"emit noalias metadata for mutable references (default: yes on LLVM >= 6)"), "emit noalias metadata for mutable references (default: yes on LLVM >= 6)"),
arg_align_attributes: bool = (false, parse_bool, [TRACKED],
"emit align metadata for reference arguments"),
dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED], dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
"dump MIR state to file. "dump MIR state to file.
`val` is used to select which passes and functions to dump. For example: `val` is used to select which passes and functions to dump. For example:

6
src/librustc_codegen_llvm/abi.rs
View file

@ -489,12 +489,6 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
attrs.pointee_size = pointee.size; attrs.pointee_size = pointee.size;
attrs.pointee_align = Some(pointee.align); attrs.pointee_align = Some(pointee.align);
// HACK(eddyb) LLVM inserts `llvm.assume` calls when inlining functions
// with align attributes, and those calls later block optimizations.
if !is_return && !cx.tcx.sess.opts.debugging_opts.arg_align_attributes {
attrs.pointee_align = None;
}
// `Box` pointer parameters never alias because ownership is transferred // `Box` pointer parameters never alias because ownership is transferred
// `&mut` pointer parameters never alias other parameters, // `&mut` pointer parameters never alias other parameters,
// or mutable global data // or mutable global data

4
src/librustc_codegen_llvm/llvm_util.rs
View file

@ -74,6 +74,10 @@ unsafe fn configure_llvm(sess: &Session) {
add("-mergefunc-use-aliases"); add("-mergefunc-use-aliases");
} }
// HACK(eddyb) LLVM inserts `llvm.assume` calls to preserve align attributes
// during inlining. Unfortunately these may block other optimizations.
add("-preserve-alignment-assumptions-during-inlining=false");
for arg in &sess.opts.cg.llvm_args { for arg in &sess.opts.cg.llvm_args {
add(&(*arg)); add(&(*arg));
} }

32
src/test/codegen/function-arguments.rs
View file

@ -28,37 +28,37 @@ pub fn boolean(x: bool) -> bool {
x x
} }
// CHECK: @readonly_borrow(i32* noalias readonly dereferenceable(4) %arg0) // CHECK: @readonly_borrow(i32* noalias readonly align 4 dereferenceable(4) %arg0)
// FIXME #25759 This should also have `nocapture` // FIXME #25759 This should also have `nocapture`
#[no_mangle] #[no_mangle]
pub fn readonly_borrow(_: &i32) { pub fn readonly_borrow(_: &i32) {
} }
// CHECK: @static_borrow(i32* noalias readonly dereferenceable(4) %arg0) // CHECK: @static_borrow(i32* noalias readonly align 4 dereferenceable(4) %arg0)
// static borrow may be captured // static borrow may be captured
#[no_mangle] #[no_mangle]
pub fn static_borrow(_: &'static i32) { pub fn static_borrow(_: &'static i32) {
} }
// CHECK: @named_borrow(i32* noalias readonly dereferenceable(4) %arg0) // CHECK: @named_borrow(i32* noalias readonly align 4 dereferenceable(4) %arg0)
// borrow with named lifetime may be captured // borrow with named lifetime may be captured
#[no_mangle] #[no_mangle]
pub fn named_borrow<'r>(_: &'r i32) { pub fn named_borrow<'r>(_: &'r i32) {
} }
// CHECK: @unsafe_borrow(i16* dereferenceable(2) %arg0) // CHECK: @unsafe_borrow(i16* align 2 dereferenceable(2) %arg0)
// unsafe interior means this isn't actually readonly and there may be aliases ... // unsafe interior means this isn't actually readonly and there may be aliases ...
#[no_mangle] #[no_mangle]
pub fn unsafe_borrow(_: &UnsafeInner) { pub fn unsafe_borrow(_: &UnsafeInner) {
} }
// CHECK: @mutable_unsafe_borrow(i16* dereferenceable(2) %arg0) // CHECK: @mutable_unsafe_borrow(i16* align 2 dereferenceable(2) %arg0)
// ... unless this is a mutable borrow, those never alias // ... unless this is a mutable borrow, those never alias
#[no_mangle] #[no_mangle]
pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) { pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) {
} }
// CHECK: @mutable_borrow(i32* dereferenceable(4) %arg0) // CHECK: @mutable_borrow(i32* align 4 dereferenceable(4) %arg0)
// FIXME #25759 This should also have `nocapture` // FIXME #25759 This should also have `nocapture`
#[no_mangle] #[no_mangle]
pub fn mutable_borrow(_: &mut i32) { pub fn mutable_borrow(_: &mut i32) {
@ -69,13 +69,13 @@ pub fn mutable_borrow(_: &mut i32) {
pub fn indirect_struct(_: S) { pub fn indirect_struct(_: S) {
} }
// CHECK: @borrowed_struct(%S* noalias readonly dereferenceable(32) %arg0) // CHECK: @borrowed_struct(%S* noalias readonly align 4 dereferenceable(32) %arg0)
// FIXME #25759 This should also have `nocapture` // FIXME #25759 This should also have `nocapture`
#[no_mangle] #[no_mangle]
pub fn borrowed_struct(_: &S) { pub fn borrowed_struct(_: &S) {
} }
// CHECK: noalias align 4 dereferenceable(4) i32* @_box(i32* noalias dereferenceable(4) %x) // CHECK: noalias align 4 dereferenceable(4) i32* @_box(i32* noalias align 4 dereferenceable(4) %x)
#[no_mangle] #[no_mangle]
pub fn _box(x: Box<i32>) -> Box<i32> { pub fn _box(x: Box<i32>) -> Box<i32> {
x x
@ -95,48 +95,48 @@ pub fn struct_return() -> S {
pub fn helper(_: usize) { pub fn helper(_: usize) {
} }
// CHECK: @slice([0 x i8]* noalias nonnull readonly %arg0.0, [[USIZE]] %arg0.1) // CHECK: @slice([0 x i8]* noalias nonnull readonly align 1 %arg0.0, [[USIZE]] %arg0.1)
// FIXME #25759 This should also have `nocapture` // FIXME #25759 This should also have `nocapture`
#[no_mangle] #[no_mangle]
pub fn slice(_: &[u8]) { pub fn slice(_: &[u8]) {
} }
// CHECK: @mutable_slice([0 x i8]* nonnull %arg0.0, [[USIZE]] %arg0.1) // CHECK: @mutable_slice([0 x i8]* nonnull align 1 %arg0.0, [[USIZE]] %arg0.1)
// FIXME #25759 This should also have `nocapture` // FIXME #25759 This should also have `nocapture`
#[no_mangle] #[no_mangle]
pub fn mutable_slice(_: &mut [u8]) { pub fn mutable_slice(_: &mut [u8]) {
} }
// CHECK: @unsafe_slice([0 x i16]* nonnull %arg0.0, [[USIZE]] %arg0.1) // CHECK: @unsafe_slice([0 x i16]* nonnull align 2 %arg0.0, [[USIZE]] %arg0.1)
// unsafe interior means this isn't actually readonly and there may be aliases ... // unsafe interior means this isn't actually readonly and there may be aliases ...
#[no_mangle] #[no_mangle]
pub fn unsafe_slice(_: &[UnsafeInner]) { pub fn unsafe_slice(_: &[UnsafeInner]) {
} }
// CHECK: @str([0 x i8]* noalias nonnull readonly %arg0.0, [[USIZE]] %arg0.1) // CHECK: @str([0 x i8]* noalias nonnull readonly align 1 %arg0.0, [[USIZE]] %arg0.1)
// FIXME #25759 This should also have `nocapture` // FIXME #25759 This should also have `nocapture`
#[no_mangle] #[no_mangle]
pub fn str(_: &[u8]) { pub fn str(_: &[u8]) {
} }
// CHECK: @trait_borrow({}* nonnull %arg0.0, [3 x [[USIZE]]]* noalias readonly dereferenceable({{.*}}) %arg0.1) // CHECK: @trait_borrow({}* nonnull align 1 %arg0.0, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}) %arg0.1)
// FIXME #25759 This should also have `nocapture` // FIXME #25759 This should also have `nocapture`
#[no_mangle] #[no_mangle]
pub fn trait_borrow(_: &Drop) { pub fn trait_borrow(_: &Drop) {
} }
// CHECK: @trait_box({}* noalias nonnull, [3 x [[USIZE]]]* noalias readonly dereferenceable({{.*}})) // CHECK: @trait_box({}* noalias nonnull align 1, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}))
#[no_mangle] #[no_mangle]
pub fn trait_box(_: Box<Drop>) { pub fn trait_box(_: Box<Drop>) {
} }
// CHECK: { i8*, i8* } @trait_option(i8* noalias %x.0, i8* %x.1) // CHECK: { i8*, i8* } @trait_option(i8* noalias align 1 %x.0, i8* %x.1)
#[no_mangle] #[no_mangle]
pub fn trait_option(x: Option<Box<Drop>>) -> Option<Box<Drop>> { pub fn trait_option(x: Option<Box<Drop>>) -> Option<Box<Drop>> {
x x
} }
// CHECK: { [0 x i16]*, [[USIZE]] } @return_slice([0 x i16]* noalias nonnull readonly %x.0, [[USIZE]] %x.1) // CHECK: { [0 x i16]*, [[USIZE]] } @return_slice([0 x i16]* noalias nonnull readonly align 2 %x.0, [[USIZE]] %x.1)
#[no_mangle] #[no_mangle]
pub fn return_slice(x: &[u16]) -> &[u16] { pub fn return_slice(x: &[u16]) -> &[u16] {
x x