Pass InferCtxt to InlineAsmCtxt to properly taint on error

compiler-errors · compiler-errors · commit 77ea82be9afd · 2025-03-07T01:54:45.000Z
Split up some of the tests bc tainting causes some errors to become
suppressed
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs b/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -101,22 +101,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         debug!("FnCtxt::check_asm: {} deferred checks", deferred_asm_checks.len());
         for (asm, hir_id) in deferred_asm_checks.drain(..) {
             let enclosing_id = self.tcx.hir_enclosing_body_owner(hir_id);
-            let expr_ty = |expr: &hir::Expr<'tcx>| {
-                let ty = self.typeck_results.borrow().expr_ty_adjusted(expr);
-                let ty = self.resolve_vars_if_possible(ty);
-                if ty.has_non_region_infer() {
-                    Ty::new_misc_error(self.tcx)
-                } else {
-                    self.tcx.erase_regions(ty)
-                }
-            };
-            let node_ty = |hir_id: HirId| self.typeck_results.borrow().node_type(hir_id);
             InlineAsmCtxt::new(
-                self.tcx,
                 enclosing_id,
+                &self.infcx,
                 self.typing_env(self.param_env),
-                expr_ty,
-                node_ty,
+                &*self.typeck_results.borrow(),
             )
             .check_asm(asm);
         }
diff --git a/tests/ui/asm/global-asm-with-error.stderr b/tests/ui/asm/global-asm-with-error.stderr
@@ -1,5 +1,5 @@
 error[E0425]: cannot find value `a` in this scope
-  --> $DIR/global-asm-with-error.rs:6:29
+  --> $DIR/global-asm-with-error.rs:8:29
    |
 LL | global_asm!("/* {} */", sym a);
    |                             ^ not found in this scope
diff --git a/tests/ui/asm/invalid-const-operand.rs b/tests/ui/asm/invalid-const-operand.rs
@@ -14,7 +14,7 @@ global_asm!("{}", const 0f32);
 global_asm!("{}", const 0 as *mut u8);
 //~^ ERROR invalid type for `const` operand
 
-fn main() {
+fn test1() {
     unsafe {
         // Const operands must be integers and must be constants.
 
@@ -27,7 +27,11 @@ fn main() {
         //~^ ERROR invalid type for `const` operand
         asm!("{}", const &0);
         //~^ ERROR invalid type for `const` operand
+    }
+}
 
+fn test2() {
+    unsafe {
         // Constants must be... constant
 
         let x = 0;
@@ -47,3 +51,5 @@ fn main() {
         //~^ ERROR attempt to use a non-constant value in a constant
     }
 }
+
+fn main() {}
diff --git a/tests/ui/asm/invalid-const-operand.stderr b/tests/ui/asm/invalid-const-operand.stderr
@@ -1,5 +1,5 @@
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/invalid-const-operand.rs:40:26
+  --> $DIR/invalid-const-operand.rs:44:26
    |
 LL |         asm!("{}", const x);
    |                          ^ non-constant value
@@ -11,7 +11,7 @@ LL +         const x: /* Type */ = 0;
    |
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/invalid-const-operand.rs:43:36
+  --> $DIR/invalid-const-operand.rs:47:36
    |
 LL |         asm!("{}", const const_foo(x));
    |                                    ^ non-constant value
@@ -23,7 +23,7 @@ LL +         const x: /* Type */ = 0;
    |
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/invalid-const-operand.rs:46:36
+  --> $DIR/invalid-const-operand.rs:50:36
    |
 LL |         asm!("{}", const const_bar(x));
    |                                    ^ non-constant value
@@ -80,7 +80,7 @@ error: invalid type for `const` operand
 LL |         asm!("{}", const &0);
    |                    ^^^^^^--
    |                          |
-   |                          is a `&{integer}`
+   |                          is a `&i32`
    |
    = help: `const` operands must be of an integer type
 
diff --git a/tests/ui/asm/tainting-on-error.rs b/tests/ui/asm/tainting-on-error.rs
@@ -0,0 +1,13 @@
+//@ needs-asm-support
+
+use std::arch::asm;
+
+fn main() {
+    unsafe {
+        asm!(
+            "/* {} */",
+            sym None::<()>,
+            //~^ ERROR invalid `sym` operand
+        );
+    }
+}
diff --git a/tests/ui/asm/tainting-on-error.stderr b/tests/ui/asm/tainting-on-error.stderr
@@ -0,0 +1,10 @@
+error: invalid `sym` operand
+  --> $DIR/tainting-on-error.rs:9:13
+   |
+LL |             sym None::<()>,
+   |             ^^^^^^^^^^^^^^ is an `Option<()>`
+   |
+   = help: `sym` operands must refer to either a function or a static
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/asm/x86_64/type-check-2.rs b/tests/ui/asm/x86_64/type-check-2.rs
@@ -7,7 +7,7 @@ use std::arch::{asm, global_asm};
 #[repr(simd)]
 struct SimdNonCopy([f32; 4]);
 
-fn main() {
+fn test1() {
     unsafe {
         // Inputs must be initialized
 
@@ -26,7 +26,11 @@ fn main() {
         asm!("{}", in(reg) v[0]);
         asm!("{}", out(reg) v[0]);
         asm!("{}", inout(reg) v[0]);
+    }
+}
 
+fn test2() {
+    unsafe {
         // Register operands must be Copy
 
         asm!("{}", in(xmm_reg) SimdNonCopy([0.0, 0.0, 0.0, 0.0]));
@@ -68,3 +72,5 @@ fn main() {
         asm!("{}", in(reg) u);
     }
 }
+
+fn main() {}
diff --git a/tests/ui/asm/x86_64/type-check-2.stderr b/tests/ui/asm/x86_64/type-check-2.stderr
@@ -1,21 +1,21 @@
 error: arguments for inline assembly must be copyable
-  --> $DIR/type-check-2.rs:32:32
+  --> $DIR/type-check-2.rs:36:32
    |
 LL |         asm!("{}", in(xmm_reg) SimdNonCopy([0.0, 0.0, 0.0, 0.0]));
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `SimdNonCopy` does not implement the Copy trait
 
-error: cannot use value of type `{closure@$DIR/type-check-2.rs:44:28: 44:36}` for inline assembly
-  --> $DIR/type-check-2.rs:44:28
+error: cannot use value of type `{closure@$DIR/type-check-2.rs:48:28: 48:36}` for inline assembly
+  --> $DIR/type-check-2.rs:48:28
    |
 LL |         asm!("{}", in(reg) |x: i32| x);
    |                            ^^^^^^^^^^
    |
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error: cannot use value of type `Vec<i32>` for inline assembly
-  --> $DIR/type-check-2.rs:46:28
+  --> $DIR/type-check-2.rs:50:28
    |
 LL |         asm!("{}", in(reg) vec![0]);
    |                            ^^^^^^^
@@ -24,31 +24,31 @@ LL |         asm!("{}", in(reg) vec![0]);
    = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: cannot use value of type `(i32, i32, i32)` for inline assembly
-  --> $DIR/type-check-2.rs:48:28
+  --> $DIR/type-check-2.rs:52:28
    |
 LL |         asm!("{}", in(reg) (1, 2, 3));
    |                            ^^^^^^^^^
    |
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error: cannot use value of type `[i32; 3]` for inline assembly
-  --> $DIR/type-check-2.rs:50:28
+  --> $DIR/type-check-2.rs:54:28
    |
 LL |         asm!("{}", in(reg) [1, 2, 3]);
    |                            ^^^^^^^^^
    |
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error: cannot use value of type `fn() {main}` for inline assembly
-  --> $DIR/type-check-2.rs:58:31
+  --> $DIR/type-check-2.rs:62:31
    |
 LL |         asm!("{}", inout(reg) f);
    |                               ^
    |
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error: cannot use value of type `&mut i32` for inline assembly
-  --> $DIR/type-check-2.rs:61:31
+  --> $DIR/type-check-2.rs:65:31
    |
 LL |         asm!("{}", inout(reg) r);
    |                               ^

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error[E0425]: cannot find value `a` in this scope
`2`		`- --> $DIR/global-asm-with-error.rs:6:29`
	`2`	`+ --> $DIR/global-asm-with-error.rs:8:29`
`3`	`3`	`\|`
`4`	`4`	`LL \| global_asm!("/* {} */", sym a);`
`5`	`5`	`\| ^ not found in this scope`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`error[E0435]: attempt to use a non-constant value in a constant`
`2`		`- --> $DIR/invalid-const-operand.rs:40:26`
	`2`	`+ --> $DIR/invalid-const-operand.rs:44:26`
`3`	`3`	`\|`
`4`	`4`	`LL \| asm!("{}", const x);`
`5`	`5`	`\| ^ non-constant value`
`@@ -11,7 +11,7 @@ LL + const x: /* Type */ = 0;`
`11`	`11`	`\|`
`12`	`12`
`13`	`13`	`error[E0435]: attempt to use a non-constant value in a constant`
`14`		`- --> $DIR/invalid-const-operand.rs:43:36`
	`14`	`+ --> $DIR/invalid-const-operand.rs:47:36`
`15`	`15`	`\|`
`16`	`16`	`LL \| asm!("{}", const const_foo(x));`
`17`	`17`	`\| ^ non-constant value`
`@@ -23,7 +23,7 @@ LL + const x: /* Type */ = 0;`
`23`	`23`	`\|`
`24`	`24`
`25`	`25`	`error[E0435]: attempt to use a non-constant value in a constant`
`26`		`- --> $DIR/invalid-const-operand.rs:46:36`
	`26`	`+ --> $DIR/invalid-const-operand.rs:50:36`
`27`	`27`	`\|`
`28`	`28`	`LL \| asm!("{}", const const_bar(x));`
`29`	`29`	`\| ^ non-constant value`
@@ -80,7 +80,7 @@ error: invalid type for `const` operand
`80`	`80`	`LL \| asm!("{}", const &0);`
`81`	`81`	`\| ^^^^^^--`
`82`	`82`	`\| \|`
`83`		- \| is a `&{integer}`
	`83`	+ \| is a `&i32`
`84`	`84`	`\|`
`85`	`85`	= help: `const` operands must be of an integer type
`86`	`86`
Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,21 @@`
`1`	`1`	`error: arguments for inline assembly must be copyable`
`2`		`- --> $DIR/type-check-2.rs:32:32`
	`2`	`+ --> $DIR/type-check-2.rs:36:32`
`3`	`3`	`\|`
`4`	`4`	`LL \| asm!("{}", in(xmm_reg) SimdNonCopy([0.0, 0.0, 0.0, 0.0]));`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `SimdNonCopy` does not implement the Copy trait
`8`	`8`
`9`		-error: cannot use value of type `{closure@$DIR/type-check-2.rs:44:28: 44:36}` for inline assembly
`10`		`- --> $DIR/type-check-2.rs:44:28`
	`9`	+error: cannot use value of type `{closure@$DIR/type-check-2.rs:48:28: 48:36}` for inline assembly
	`10`	`+ --> $DIR/type-check-2.rs:48:28`
`11`	`11`	`\|`
`12`	`12`	`LL \| asm!("{}", in(reg) \|x: i32\| x);`
`13`	`13`	`\| ^^^^^^^^^^`
`14`	`14`	`\|`
`15`	`15`	`= note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly`
`16`	`16`
`17`	`17`	error: cannot use value of type `Vec<i32>` for inline assembly
`18`		`- --> $DIR/type-check-2.rs:46:28`
	`18`	`+ --> $DIR/type-check-2.rs:50:28`
`19`	`19`	`\|`
`20`	`20`	`LL \| asm!("{}", in(reg) vec![0]);`
`21`	`21`	`\| ^^^^^^^`
`@@ -24,31 +24,31 @@ LL \| asm!("{}", in(reg) vec![0]);`
`24`	`24`	= note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
`25`	`25`
`26`	`26`	error: cannot use value of type `(i32, i32, i32)` for inline assembly
`27`		`- --> $DIR/type-check-2.rs:48:28`
	`27`	`+ --> $DIR/type-check-2.rs:52:28`
`28`	`28`	`\|`
`29`	`29`	`LL \| asm!("{}", in(reg) (1, 2, 3));`
`30`	`30`	`\| ^^^^^^^^^`
`31`	`31`	`\|`
`32`	`32`	`= note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly`
`33`	`33`
`34`	`34`	error: cannot use value of type `[i32; 3]` for inline assembly
`35`		`- --> $DIR/type-check-2.rs:50:28`
	`35`	`+ --> $DIR/type-check-2.rs:54:28`
`36`	`36`	`\|`
`37`	`37`	`LL \| asm!("{}", in(reg) [1, 2, 3]);`
`38`	`38`	`\| ^^^^^^^^^`
`39`	`39`	`\|`
`40`	`40`	`= note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly`
`41`	`41`
`42`	`42`	error: cannot use value of type `fn() {main}` for inline assembly
`43`		`- --> $DIR/type-check-2.rs:58:31`
	`43`	`+ --> $DIR/type-check-2.rs:62:31`
`44`	`44`	`\|`
`45`	`45`	`LL \| asm!("{}", inout(reg) f);`
`46`	`46`	`\| ^`
`47`	`47`	`\|`
`48`	`48`	`= note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly`
`49`	`49`
`50`	`50`	error: cannot use value of type `&mut i32` for inline assembly
`51`		`- --> $DIR/type-check-2.rs:61:31`
	`51`	`+ --> $DIR/type-check-2.rs:65:31`
`52`	`52`	`\|`
`53`	`53`	`LL \| asm!("{}", inout(reg) r);`
`54`	`54`	`\| ^`