deduced_param_attrs: check Freeze on monomorphic types.

Author: cjgillot

compiler/rustc_mir_transform/src/deduce_param_attrs.rs

@@ -169,20 +169,9 @@ pub(super) fn deduced_param_attrs<'tcx>(
     // see [1].
     //
     // [1]: https://github.com/rust-lang/rust/pull/103172#discussion_r999139997
-    let typing_env = body.typing_env(tcx);
-    let mut deduced_param_attrs = tcx.arena.alloc_from_iter(
-        body.local_decls.iter().skip(1).take(body.arg_count).enumerate().map(
-            |(arg_index, local_decl)| DeducedParamAttrs {
-                read_only: !deduce_read_only.mutable_args.contains(arg_index)
-                    // We must normalize here to reveal opaques and normalize
-                    // their generic parameters, otherwise we'll see exponential
-                    // blow-up in compile times: #113372
-                    && tcx
-                        .normalize_erasing_regions(typing_env, local_decl.ty)
-                        .is_freeze(tcx, typing_env),
-            },
-        ),
-    );
+    let mut deduced_param_attrs = tcx.arena.alloc_from_iter((0..body.arg_count).map(|arg_index| {
+        DeducedParamAttrs { read_only: !deduce_read_only.mutable_args.contains(arg_index) }
+    }));
 
     // Trailing parameters past the size of the `deduced_param_attrs` array are assumed to have the
     // default set of attributes, so we don't have to store them explicitly. Pop them off to save a

compiler/rustc_ty_utils/src/abi.rs

@@ -641,6 +641,7 @@ fn fn_abi_adjust_for_abi<'tcx>(
                 // bounds.
                 if let Some(deduced_param_attrs) = deduced_param_attrs.get(arg_idx)
                     && deduced_param_attrs.read_only
+                    && arg.layout.ty.is_freeze(tcx, cx.typing_env)
                 {
                     attrs.regular.insert(ArgAttribute::ReadOnly);
                     debug!("added deduced read-only attribute");

tests/codegen-llvm/deduced-param-attrs.rs

@@ -1,4 +1,4 @@
-//@ compile-flags: -Copt-level=3
+//@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes
 
 #![crate_type = "lib"]
 #![allow(internal_features)]
@@ -28,7 +28,9 @@ pub fn use_big_struct_immutably(big_struct: BigStruct) {
 
 // The by-value parameter for this big struct can't be marked readonly, because we mutate it.
 //
-// CHECK-NOT: @use_big_struct_mutably({{.*}} readonly {{.*}} %big_struct)
+// CHECK: @use_big_struct_mutably(
+// CHECK-NOT: readonly
+// CHECK-SAME: %big_struct)
 #[no_mangle]
 pub fn use_big_struct_mutably(mut big_struct: BigStruct) {
     big_struct.blah[987] = 654;
@@ -38,7 +40,9 @@ pub fn use_big_struct_mutably(mut big_struct: BigStruct) {
 // The by-value parameter for this big struct can't be marked readonly, because it contains
 // UnsafeCell.
 //
-// CHECK-NOT: @use_big_cell_container({{.*}} readonly {{.*}} %big_cell_container)
+// CHECK: @use_big_cell_container(
+// CHECK-NOT: readonly
+// CHECK-SAME: %big_cell_container)
 #[no_mangle]
 pub fn use_big_cell_container(big_cell_container: BigCellContainer) {
     hint::black_box(&big_cell_container);
@@ -47,14 +51,34 @@ pub fn use_big_cell_container(big_cell_container: BigCellContainer) {
 // Make sure that we don't mistakenly mark a big struct as `readonly` when passed through a generic
 // type parameter if it contains UnsafeCell.
 //
-// CHECK-NOT: @use_something({{.*}} readonly {{.*}} %something)
+// CHECK: @use_something(
+// CHECK-NOT: readonly
+// CHECK-SAME: %something)
 #[no_mangle]
 #[inline(never)]
 pub fn use_something<T>(something: T) {
     hint::black_box(&something);
 }
 
+// Make sure that we still mark a big `Freeze` struct as `readonly` when passed through a generic
+// type parameter.
+//
+// CHECK: @use_something_freeze(
+// CHECK-SAME: readonly
+// CHECK-SAME: %x)
+#[no_mangle]
+#[inline(never)]
+pub fn use_something_freeze<T>(x: T) {
+    // `Drop` counts as a mutable use.
+    std::mem::forget(x)
+}
+
 #[no_mangle]
 pub fn forward_big_cell_container(big_cell_container: BigCellContainer) {
     use_something(big_cell_container)
 }
+
+#[no_mangle]
+pub fn forward_big_container(big_struct: BigStruct) {
+    use_something_freeze(big_struct)
+}