nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 08:13:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

stabilize asm_const

Browse Source
This commit is contained in:
Folkert 2024-08-10 18:13:03 +02:00 committed by Folkert de Vries
parent 80eb5a8e91
commit 8419c0956e
43 changed files with 294 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_ast_lowering/messages.ftl
View File

@ -175,8 +175,6 @@ ast_lowering_underscore_expr_lhs_assign =
.label = `_` not allowed here
ast_lowering_unstable_inline_assembly = inline assembly is not stable yet on this architecture
ast_lowering_unstable_inline_assembly_const_operands =
const operands for inline assembly are unstable
ast_lowering_unstable_inline_assembly_label_operands =
label operands for inline assembly are unstable
ast_lowering_unstable_may_unwind = the `may_unwind` option is unstable

17
compiler/rustc_ast_lowering/src/asm.rs
View File

@ -183,20 +183,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
out_expr: out_expr.as_ref().map(|expr| self.lower_expr(expr)),
}
}
InlineAsmOperand::Const { anon_const } => {
if !self.tcx.features().asm_const {
feature_err(
sess,
sym::asm_const,
*op_sp,
fluent::ast_lowering_unstable_inline_assembly_const_operands,
)
.emit();
}
hir::InlineAsmOperand::Const {
anon_const: self.lower_anon_const_to_anon_const(anon_const),
}
}
InlineAsmOperand::Const { anon_const } => hir::InlineAsmOperand::Const {
anon_const: self.lower_anon_const_to_anon_const(anon_const),
},
InlineAsmOperand::Sym { sym } => {
let static_def_id = self
.resolver

15
compiler/rustc_codegen_gcc/tests/run/asm.rs
View File

@ -3,12 +3,10 @@
// Run-time:
// status: 0
#![feature(asm_const)]
#[cfg(target_arch="x86_64")]
#[cfg(target_arch = "x86_64")]
use std::arch::{asm, global_asm};
#[cfg(target_arch="x86_64")]
#[cfg(target_arch = "x86_64")]
global_asm!(
"
.global add_asm
@ -22,7 +20,7 @@ extern "C" {
fn add_asm(a: i64, b: i64) -> i64;
}
#[cfg(target_arch="x86_64")]
#[cfg(target_arch = "x86_64")]
pub unsafe fn mem_cpy(dst: *mut u8, src: *const u8, len: usize) {
asm!(
"rep movsb",
@ -33,7 +31,7 @@ pub unsafe fn mem_cpy(dst: *mut u8, src: *const u8, len: usize) {
);
}
#[cfg(target_arch="x86_64")]
#[cfg(target_arch = "x86_64")]
fn asm() {
unsafe {
asm!("nop");
@ -178,9 +176,8 @@ fn asm() {
assert_eq!(array1, array2);
}
#[cfg(not(target_arch="x86_64"))]
fn asm() {
}
#[cfg(not(target_arch = "x86_64"))]
fn asm() {}
fn main() {
asm();

2
compiler/rustc_feature/src/accepted.rs
View File

@ -60,6 +60,8 @@ declare_features! (
(accepted, adx_target_feature, "1.61.0", Some(44839)),
/// Allows explicit discriminants on non-unit enum variants.
(accepted, arbitrary_enum_discriminant, "1.66.0", Some(60553)),
/// Allows using `const` operands in inline assembly.
(accepted, asm_const, "CURRENT_RUSTC_VERSION", Some(93332)),
/// Allows using `sym` operands in inline assembly.
(accepted, asm_sym, "1.66.0", Some(93333)),
/// Allows the definition of associated constants in `trait` or `impl` blocks.

2
compiler/rustc_feature/src/unstable.rs
View File

@ -348,8 +348,6 @@ declare_features! (
(unstable, alloc_error_handler, "1.29.0", Some(51540)),
/// Allows trait methods with arbitrary self types.
(unstable, arbitrary_self_types, "1.23.0", Some(44874)),
/// Allows using `const` operands in inline assembly.
(unstable, asm_const, "1.58.0", Some(93332)),
/// Enables experimental inline assembly support for additional architectures.
(unstable, asm_experimental_arch, "1.58.0", Some(93335)),
/// Allows using `label` operands in inline assembly.

2
library/core/src/lib.rs
View File

@ -192,12 +192,12 @@
//
// Language features:
// tidy-alphabetical-start
#![cfg_attr(bootstrap, feature(asm_const))]
#![cfg_attr(bootstrap, feature(min_exhaustive_patterns))]
#![feature(abi_unadjusted)]
#![feature(adt_const_params)]
#![feature(allow_internal_unsafe)]
#![feature(allow_internal_unstable)]
#![feature(asm_const)]
#![feature(auto_traits)]
#![feature(cfg_sanitize)]
#![feature(cfg_target_has_atomic)]

11
src/doc/unstable-book/src/language-features/asm-const.md
View File

@ -1,11 +0,0 @@
# `asm_const`
The tracking issue for this feature is: [#93332]
[#93332]: https://github.com/rust-lang/rust/issues/93332
------------------------
This feature adds a `const <expr>` operand type to `asm!` and `global_asm!`.
- `<expr>` must be an integer constant expression.
- The value of the expression is formatted as a string and substituted directly into the asm template string.

1
tests/assembly/asm/global_asm.rs
View File

@ -4,7 +4,6 @@
//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
//@ compile-flags: -C symbol-mangling-version=v0
#![feature(asm_const)]
#![crate_type = "rlib"]
use std::arch::global_asm;

2
tests/assembly/asm/msp430-types.rs
View File

@ -2,7 +2,7 @@
//@ compile-flags: --target msp430-none-elf
//@ needs-llvm-components: msp430
#![feature(no_core, lang_items, rustc_attrs, asm_experimental_arch, asm_const)]
#![feature(no_core, lang_items, rustc_attrs, asm_experimental_arch)]
#![crate_type = "rlib"]
#![no_core]
#![allow(non_camel_case_types)]

2
tests/ui/asm/aarch64/bad-reg.rs
View File

@ -1,8 +1,6 @@
//@ only-aarch64
//@ compile-flags: -C target-feature=+neon
#![feature(asm_const)]
use std::arch::asm;
fn main() {

44
tests/ui/asm/aarch64/bad-reg.stderr
View File

@ -1,17 +1,17 @@
error: invalid register class `foo`: unknown register class
--> $DIR/bad-reg.rs:14:20
--> $DIR/bad-reg.rs:12:20
|
LL | asm!("{}", in(foo) foo);
| ^^^^^^^^^^^
error: invalid register `foo`: unknown register
--> $DIR/bad-reg.rs:16:18
--> $DIR/bad-reg.rs:14:18
|
LL | asm!("", in("foo") foo);
| ^^^^^^^^^^^^^
error: invalid asm template modifier for this register class
--> $DIR/bad-reg.rs:18:15
--> $DIR/bad-reg.rs:16:15
|
LL | asm!("{:z}", in(reg) foo);
| ^^^^ ----------- argument
@ -21,7 +21,7 @@ LL | asm!("{:z}", in(reg) foo);
= note: the `reg` register class supports the following template modifiers: `w`, `x`
error: invalid asm template modifier for this register class
--> $DIR/bad-reg.rs:20:15
--> $DIR/bad-reg.rs:18:15
|
LL | asm!("{:r}", in(vreg) foo);
| ^^^^ ------------ argument
@ -31,7 +31,7 @@ LL | asm!("{:r}", in(vreg) foo);
= note: the `vreg` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, `v`
error: invalid asm template modifier for this register class
--> $DIR/bad-reg.rs:22:15
--> $DIR/bad-reg.rs:20:15
|
LL | asm!("{:r}", in(vreg_low16) foo);
| ^^^^ ------------------ argument
@ -41,7 +41,7 @@ LL | asm!("{:r}", in(vreg_low16) foo);
= note: the `vreg_low16` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, `v`
error: asm template modifiers are not allowed for `const` arguments
--> $DIR/bad-reg.rs:24:15
--> $DIR/bad-reg.rs:22:15
|
LL | asm!("{:a}", const 0);
| ^^^^ ------- argument
@ -49,7 +49,7 @@ LL | asm!("{:a}", const 0);
| template modifier
error: asm template modifiers are not allowed for `sym` arguments
--> $DIR/bad-reg.rs:26:15
--> $DIR/bad-reg.rs:24:15
|
LL | asm!("{:a}", sym main);
| ^^^^ -------- argument
@ -57,49 +57,49 @@ LL | asm!("{:a}", sym main);
| template modifier
error: invalid register `x29`: the frame pointer cannot be used as an operand for inline asm
--> $DIR/bad-reg.rs:28:18
--> $DIR/bad-reg.rs:26:18
|
LL | asm!("", in("x29") foo);
| ^^^^^^^^^^^^^
error: invalid register `sp`: the stack pointer cannot be used as an operand for inline asm
--> $DIR/bad-reg.rs:30:18
--> $DIR/bad-reg.rs:28:18
|
LL | asm!("", in("sp") foo);
| ^^^^^^^^^^^^
error: invalid register `xzr`: the zero register cannot be used as an operand for inline asm
--> $DIR/bad-reg.rs:32:18
--> $DIR/bad-reg.rs:30:18
|
LL | asm!("", in("xzr") foo);
| ^^^^^^^^^^^^^
error: invalid register `x19`: x19 is used internally by LLVM and cannot be used as an operand for inline asm
--> $DIR/bad-reg.rs:34:18
--> $DIR/bad-reg.rs:32:18
|
LL | asm!("", in("x19") foo);
| ^^^^^^^^^^^^^
error: register class `preg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:37:18
--> $DIR/bad-reg.rs:35:18
|
LL | asm!("", in("p0") foo);
| ^^^^^^^^^^^^
error: register class `preg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:41:20
--> $DIR/bad-reg.rs:39:20
|
LL | asm!("{}", in(preg) foo);
| ^^^^^^^^^^^^
error: register class `preg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:44:20
--> $DIR/bad-reg.rs:42:20
|
LL | asm!("{}", out(preg) _);
| ^^^^^^^^^^^
error: register `w0` conflicts with register `x0`
--> $DIR/bad-reg.rs:50:32
--> $DIR/bad-reg.rs:48:32
|
LL | asm!("", in("x0") foo, in("w0") bar);
| ------------ ^^^^^^^^^^^^ register `w0`
@ -107,7 +107,7 @@ LL | asm!("", in("x0") foo, in("w0") bar);
| register `x0`
error: register `x0` conflicts with register `x0`
--> $DIR/bad-reg.rs:52:32
--> $DIR/bad-reg.rs:50:32
|
LL | asm!("", in("x0") foo, out("x0") bar);
| ------------ ^^^^^^^^^^^^^ register `x0`
@ -115,13 +115,13 @@ LL | asm!("", in("x0") foo, out("x0") bar);
| register `x0`
|
help: use `lateout` instead of `out` to avoid conflict
--> $DIR/bad-reg.rs:52:18
--> $DIR/bad-reg.rs:50:18
|
LL | asm!("", in("x0") foo, out("x0") bar);
| ^^^^^^^^^^^^
error: register `q0` conflicts with register `v0`
--> $DIR/bad-reg.rs:55:32
--> $DIR/bad-reg.rs:53:32
|
LL | asm!("", in("v0") foo, in("q0") bar);
| ------------ ^^^^^^^^^^^^ register `q0`
@ -129,7 +129,7 @@ LL | asm!("", in("v0") foo, in("q0") bar);
| register `v0`
error: register `q0` conflicts with register `v0`
--> $DIR/bad-reg.rs:57:32
--> $DIR/bad-reg.rs:55:32
|
LL | asm!("", in("v0") foo, out("q0") bar);
| ------------ ^^^^^^^^^^^^^ register `q0`
@ -137,13 +137,13 @@ LL | asm!("", in("v0") foo, out("q0") bar);
| register `v0`
|
help: use `lateout` instead of `out` to avoid conflict
--> $DIR/bad-reg.rs:57:18
--> $DIR/bad-reg.rs:55:18
|
LL | asm!("", in("v0") foo, out("q0") bar);
| ^^^^^^^^^^^^
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:37:27
--> $DIR/bad-reg.rs:35:27
|
LL | asm!("", in("p0") foo);
| ^^^
@ -151,7 +151,7 @@ LL | asm!("", in("p0") foo);
= note: register class `preg` supports these types:
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:41:29
--> $DIR/bad-reg.rs:39:29
|
LL | asm!("{}", in(preg) foo);
| ^^^

2
tests/ui/asm/aarch64/const.rs
View File

@ -2,8 +2,6 @@
//@ run-pass
//@ needs-asm-support
#![feature(asm_const)]
use std::arch::{asm, global_asm};
fn const_generic<const X: usize>() -> usize {

2
tests/ui/asm/aarch64/parse-error.rs
View File

@ -1,7 +1,5 @@
//@ only-aarch64
#![feature(asm_const)]
use std::arch::{asm, global_asm};
fn main() {

136
tests/ui/asm/aarch64/parse-error.stderr
View File

@ -1,107 +1,107 @@
error: requires at least a template string argument
--> $DIR/parse-error.rs:11:9
--> $DIR/parse-error.rs:9:9
|
LL | asm!();
| ^^^^^^
error: asm template must be a string literal
--> $DIR/parse-error.rs:13:14
--> $DIR/parse-error.rs:11:14
|
LL | asm!(foo);
| ^^^
error: expected token: `,`
--> $DIR/parse-error.rs:15:19
--> $DIR/parse-error.rs:13:19
|
LL | asm!("{}" foo);
| ^^^ expected `,`
error: expected operand, clobber_abi, options, or additional template string
--> $DIR/parse-error.rs:17:20
--> $DIR/parse-error.rs:15:20
|
LL | asm!("{}", foo);
| ^^^ expected operand, clobber_abi, options, or additional template string
error: expected `(`, found `foo`
--> $DIR/parse-error.rs:19:23
--> $DIR/parse-error.rs:17:23
|
LL | asm!("{}", in foo);
| ^^^ expected `(`
error: expected `)`, found `foo`
--> $DIR/parse-error.rs:21:27
--> $DIR/parse-error.rs:19:27
|
LL | asm!("{}", in(reg foo));
| ^^^ expected `)`
error: expected expression, found end of macro arguments
--> $DIR/parse-error.rs:23:27
--> $DIR/parse-error.rs:21:27
|
LL | asm!("{}", in(reg));
| ^ expected expression
error: expected register class or explicit register
--> $DIR/parse-error.rs:25:26
--> $DIR/parse-error.rs:23:26
|
LL | asm!("{}", inout(=) foo => bar);
| ^
error: expected expression, found end of macro arguments
--> $DIR/parse-error.rs:27:37
--> $DIR/parse-error.rs:25:37
|
LL | asm!("{}", inout(reg) foo =>);
| ^ expected expression
error: expected one of `!`, `,`, `.`, `::`, `?`, `{`, or an operator, found `=>`
--> $DIR/parse-error.rs:29:32
--> $DIR/parse-error.rs:27:32
|
LL | asm!("{}", in(reg) foo => bar);
| ^^ expected one of 7 possible tokens
error: expected a path for argument to `sym`
--> $DIR/parse-error.rs:31:24
--> $DIR/parse-error.rs:29:24
|
LL | asm!("{}", sym foo + bar);
| ^^^^^^^^^
error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
--> $DIR/parse-error.rs:33:26
--> $DIR/parse-error.rs:31:26
|
LL | asm!("", options(foo));
| ^^^ expected one of 10 possible tokens
error: expected one of `)` or `,`, found `foo`
--> $DIR/parse-error.rs:35:32
--> $DIR/parse-error.rs:33:32
|
LL | asm!("", options(nomem foo));
| ^^^ expected one of `)` or `,`
error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
--> $DIR/parse-error.rs:37:33
--> $DIR/parse-error.rs:35:33
|
LL | asm!("", options(nomem, foo));
| ^^^ expected one of 10 possible tokens
error: expected string literal
--> $DIR/parse-error.rs:41:30
--> $DIR/parse-error.rs:39:30
|
LL | asm!("", clobber_abi(foo));
| ^^^ not a string literal
error: expected one of `)` or `,`, found `foo`
--> $DIR/parse-error.rs:43:34
--> $DIR/parse-error.rs:41:34
|
LL | asm!("", clobber_abi("C" foo));
| ^^^ expected one of `)` or `,`
error: expected string literal
--> $DIR/parse-error.rs:45:35
--> $DIR/parse-error.rs:43:35
|
LL | asm!("", clobber_abi("C", foo));
| ^^^ not a string literal
error: duplicate argument named `a`
--> $DIR/parse-error.rs:52:36
--> $DIR/parse-error.rs:50:36
|
LL | asm!("{a}", a = const foo, a = const bar);
| ------------- ^^^^^^^^^^^^^ duplicate argument
@ -109,7 +109,7 @@ LL | asm!("{a}", a = const foo, a = const bar);
| previously here
error: argument never used
--> $DIR/parse-error.rs:52:36
--> $DIR/parse-error.rs:50:36
|
LL | asm!("{a}", a = const foo, a = const bar);
| ^^^^^^^^^^^^^ argument never used
@ -117,13 +117,13 @@ LL | asm!("{a}", a = const foo, a = const bar);
= help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
error: explicit register arguments cannot have names
--> $DIR/parse-error.rs:57:18
--> $DIR/parse-error.rs:55:18
|
LL | asm!("", a = in("x0") foo);
| ^^^^^^^^^^^^^^^^
error: positional arguments cannot follow named arguments or explicit register arguments
--> $DIR/parse-error.rs:63:35
--> $DIR/parse-error.rs:61:35
|
LL | asm!("{1}", in("x0") foo, const bar);
| ------------ ^^^^^^^^^ positional argument
@ -131,19 +131,19 @@ LL | asm!("{1}", in("x0") foo, const bar);
| explicit register argument
error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `""`
--> $DIR/parse-error.rs:66:29
--> $DIR/parse-error.rs:64:29
|
LL | asm!("", options(), "");
| ^^ expected one of 10 possible tokens
error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `"{}"`
--> $DIR/parse-error.rs:68:33
--> $DIR/parse-error.rs:66:33
|
LL | asm!("{}", in(reg) foo, "{}", out(reg) foo);
| ^^^^ expected one of 10 possible tokens
error: asm template must be a string literal
--> $DIR/parse-error.rs:70:14
--> $DIR/parse-error.rs:68:14
|
LL | asm!(format!("{{{}}}", 0), in(reg) foo);
| ^^^^^^^^^^^^^^^^^^^^
@ -151,7 +151,7 @@ LL | asm!(format!("{{{}}}", 0), in(reg) foo);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error: asm template must be a string literal
--> $DIR/parse-error.rs:72:21
--> $DIR/parse-error.rs:70:21
|
LL | asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
| ^^^^^^^^^^^^^^^^^^^^
@ -159,127 +159,127 @@ LL | asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error: _ cannot be used for input operands
--> $DIR/parse-error.rs:74:28
--> $DIR/parse-error.rs:72:28
|
LL | asm!("{}", in(reg) _);
| ^
error: _ cannot be used for input operands
--> $DIR/parse-error.rs:76:31
--> $DIR/parse-error.rs:74:31
|
LL | asm!("{}", inout(reg) _);
| ^
error: _ cannot be used for input operands
--> $DIR/parse-error.rs:78:35
--> $DIR/parse-error.rs:76:35
|
LL | asm!("{}", inlateout(reg) _);
| ^
error: requires at least a template string argument
--> $DIR/parse-error.rs:85:1
--> $DIR/parse-error.rs:83:1
|
LL | global_asm!();
| ^^^^^^^^^^^^^
error: asm template must be a string literal
--> $DIR/parse-error.rs:87:13
--> $DIR/parse-error.rs:85:13
|
LL | global_asm!(FOO);
| ^^^
error: expected token: `,`
--> $DIR/parse-error.rs:89:18
--> $DIR/parse-error.rs:87:18
|
LL | global_asm!("{}" FOO);
| ^^^ expected `,`
error: expected operand, options, or additional template string
--> $DIR/parse-error.rs:91:19
--> $DIR/parse-error.rs:89:19
|
LL | global_asm!("{}", FOO);
| ^^^ expected operand, options, or additional template string
error: expected expression, found end of macro arguments
--> $DIR/parse-error.rs:93:24
--> $DIR/parse-error.rs:91:24
|
LL | global_asm!("{}", const);
| ^ expected expression
error: expected one of `,`, `.`, `?`, or an operator, found `FOO`
--> $DIR/parse-error.rs:95:30
--> $DIR/parse-error.rs:93:30
|
LL | global_asm!("{}", const(reg) FOO);
| ^^^ expected one of `,`, `.`, `?`, or an operator
error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
--> $DIR/parse-error.rs:97:25
--> $DIR/parse-error.rs:95:25
|
LL | global_asm!("", options(FOO));
| ^^^ expected one of `)`, `att_syntax`, or `raw`
error: the `nomem` option cannot be used with `global_asm!`
--> $DIR/parse-error.rs:99:25
--> $DIR/parse-error.rs:97:25
|
LL | global_asm!("", options(nomem FOO));
| ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
error: expected one of `)` or `,`, found `FOO`
--> $DIR/parse-error.rs:99:31
--> $DIR/parse-error.rs:97:31
|
LL | global_asm!("", options(nomem FOO));
| ^^^ expected one of `)` or `,`
error: the `nomem` option cannot be used with `global_asm!`
--> $DIR/parse-error.rs:102:25
--> $DIR/parse-error.rs:100:25
|
LL | global_asm!("", options(nomem, FOO));
| ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
--> $DIR/parse-error.rs:102:32
--> $DIR/parse-error.rs:100:32
|
LL | global_asm!("", options(nomem, FOO));
| ^^^ expected one of `)`, `att_syntax`, or `raw`
error: expected string literal
--> $DIR/parse-error.rs:106:29
--> $DIR/parse-error.rs:104:29
|
LL | global_asm!("", clobber_abi(FOO));
| ^^^ not a string literal
error: expected one of `)` or `,`, found `FOO`
--> $DIR/parse-error.rs:108:33
--> $DIR/parse-error.rs:106:33
|
LL | global_asm!("", clobber_abi("C" FOO));
| ^^^ expected one of `)` or `,`
error: expected string literal
--> $DIR/parse-error.rs:110:34
--> $DIR/parse-error.rs:108:34
|
LL | global_asm!("", clobber_abi("C", FOO));
| ^^^ not a string literal
error: `clobber_abi` cannot be used with `global_asm!`
--> $DIR/parse-error.rs:112:19
--> $DIR/parse-error.rs:110:19
|
LL | global_asm!("{}", clobber_abi("C"), const FOO);
| ^^^^^^^^^^^^^^^^
error: `clobber_abi` cannot be used with `global_asm!`
--> $DIR/parse-error.rs:114:28
--> $DIR/parse-error.rs:112:28
|
LL | global_asm!("", options(), clobber_abi("C"));
| ^^^^^^^^^^^^^^^^
error: `clobber_abi` cannot be used with `global_asm!`
--> $DIR/parse-error.rs:116:30
--> $DIR/parse-error.rs:114:30
|
LL | global_asm!("{}", options(), clobber_abi("C"), const FOO);
| ^^^^^^^^^^^^^^^^
error: duplicate argument named `a`
--> $DIR/parse-error.rs:118:35
--> $DIR/parse-error.rs:116:35
|
LL | global_asm!("{a}", a = const FOO, a = const BAR);
| ------------- ^^^^^^^^^^^^^ duplicate argument
@ -287,7 +287,7 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
| previously here
error: argument never used
--> $DIR/parse-error.rs:118:35
--> $DIR/parse-error.rs:116:35
|
LL | global_asm!("{a}", a = const FOO, a = const BAR);
| ^^^^^^^^^^^^^ argument never used
@ -295,19 +295,19 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
= help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `""`
--> $DIR/parse-error.rs:121:28
--> $DIR/parse-error.rs:119:28
|
LL | global_asm!("", options(), "");
| ^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `"{}"`
--> $DIR/parse-error.rs:123:30
--> $DIR/parse-error.rs:121:30
|
LL | global_asm!("{}", const FOO, "{}", const FOO);
| ^^^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
error: asm template must be a string literal
--> $DIR/parse-error.rs:125:13
--> $DIR/parse-error.rs:123:13
|
LL | global_asm!(format!("{{{}}}", 0), const FOO);
| ^^^^^^^^^^^^^^^^^^^^
@ -315,7 +315,7 @@ LL | global_asm!(format!("{{{}}}", 0), const FOO);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error: asm template must be a string literal
--> $DIR/parse-error.rs:127:20
--> $DIR/parse-error.rs:125:20
|
LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
| ^^^^^^^^^^^^^^^^^^^^
@ -323,7 +323,7 @@ LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:39:37
--> $DIR/parse-error.rs:37:37
|
LL | asm!("{}", options(), const foo);
| ^^^ non-constant value
@ -334,7 +334,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:47:44
--> $DIR/parse-error.rs:45:44
|
LL | asm!("{}", clobber_abi("C"), const foo);
| ^^^ non-constant value
@ -345,7 +345,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:50:55
--> $DIR/parse-error.rs:48:55
|
LL | asm!("{}", options(), clobber_abi("C"), const foo);
| ^^^ non-constant value
@ -356,7 +356,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:52:31
--> $DIR/parse-error.rs:50:31
|
LL | asm!("{a}", a = const foo, a = const bar);
| ^^^ non-constant value
@ -367,7 +367,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:52:46
--> $DIR/parse-error.rs:50:46
|
LL | asm!("{a}", a = const foo, a = const bar);
| ^^^ non-constant value
@ -377,6 +377,17 @@ help: consider using `const` instead of `let`
LL | const bar: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:57:45
|
LL | asm!("{a}", in("x0") foo, a = const bar);
| ^^^ non-constant value
|
help: consider using `const` instead of `let`
|
LL | const bar: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:59:45
|
@ -389,18 +400,7 @@ LL | const bar: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:61:45
|
LL | asm!("{a}", in("x0") foo, a = const bar);
| ^^^ non-constant value
|
help: consider using `const` instead of `let`
|
LL | const bar: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:63:41
--> $DIR/parse-error.rs:61:41
|
LL | asm!("{1}", in("x0") foo, const bar);
| ^^^ non-constant value

2
tests/ui/asm/aarch64/type-check-3.rs
View File

@ -1,7 +1,7 @@
//@ only-aarch64
//@ compile-flags: -C target-feature=+neon
#![feature(repr_simd, asm_const)]
#![feature(repr_simd)]
use std::arch::aarch64::float64x2_t;
use std::arch::{asm, global_asm};

5
tests/ui/asm/aarch64/type-check-4.rs
View File

@ -1,7 +1,7 @@
//@ only-aarch64
//@ compile-flags: -C target-feature=+neon
#![feature(repr_simd, asm_const)]
#![feature(repr_simd)]
use std::arch::aarch64::float64x2_t;
use std::arch::{asm, global_asm};
@ -10,8 +10,7 @@ use std::arch::{asm, global_asm};
#[derive(Copy, Clone)]
struct Simd256bit(f64, f64, f64, f64);
fn main() {
}
fn main() {}
// Constants must be... constant

6
tests/ui/asm/aarch64/type-check-4.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: referencing statics in constants is unstable
--> $DIR/type-check-4.rs:25:25
--> $DIR/type-check-4.rs:24:25
|
LL | global_asm!("{}", const S);
| ^
@ -11,7 +11,7 @@ LL | global_asm!("{}", const S);
= help: to fix this, the value can be extracted to a `const` and then used.
error[E0658]: referencing statics in constants is unstable
--> $DIR/type-check-4.rs:28:35
--> $DIR/type-check-4.rs:27:35
|
LL | global_asm!("{}", const const_foo(S));
| ^
@ -23,7 +23,7 @@ LL | global_asm!("{}", const const_foo(S));
= help: to fix this, the value can be extracted to a `const` and then used.
error[E0658]: referencing statics in constants is unstable
--> $DIR/type-check-4.rs:31:35
--> $DIR/type-check-4.rs:30:35
|
LL | global_asm!("{}", const const_bar(S));
| ^

2
tests/ui/asm/bad-template.rs
View File

@ -6,7 +6,7 @@
//@ [x86_64] needs-llvm-components: x86
//@ [aarch64] needs-llvm-components: aarch64
#![feature(no_core, lang_items, rustc_attrs, asm_const)]
#![feature(no_core, lang_items, rustc_attrs)]
#![no_core]
#[rustc_builtin_macro]

8
tests/ui/asm/const-error.rs
View File

@ -1,15 +1,15 @@
//@ only-x86_64
//@ needs-asm-support
#![feature(asm_const)]
// Test to make sure that we emit const errors eagerly for inline asm
use std::arch::asm;
fn test<T>() {
unsafe { asm!("/* {} */", const 1 / 0); }
//~^ ERROR evaluation of
unsafe {
asm!("/* {} */", const 1 / 0);
//~^ ERROR evaluation of
}
}
fn main() {}

6
tests/ui/asm/const-error.stderr
View File

@ -1,8 +1,8 @@
error[E0080]: evaluation of `test::<T>::{constant#0}` failed
--> $DIR/const-error.rs:11:37
--> $DIR/const-error.rs:10:32
|
LL | unsafe { asm!("/* {} */", const 1 / 0); }
| ^^^^^ attempt to divide `1_i32` by zero
LL | asm!("/* {} */", const 1 / 0);
| ^^^^^ attempt to divide `1_i32` by zero
error: aborting due to 1 previous error

1
tests/ui/asm/fail-const-eval-issue-121099.rs
View File

@ -1,6 +1,5 @@
//@ build-fail
//@ needs-asm-support
#![feature(asm_const)]
use std::arch::global_asm;

4
tests/ui/asm/fail-const-eval-issue-121099.stderr
View File

@ -1,11 +1,11 @@
error[E0080]: evaluation of constant value failed
--> $DIR/fail-const-eval-issue-121099.rs:9:31
--> $DIR/fail-const-eval-issue-121099.rs:8:31
|
LL | global_asm!("/* {} */", const 1 << 500);
| ^^^^^^^^ attempt to shift left by `500_i32`, which would overflow
error[E0080]: evaluation of constant value failed
--> $DIR/fail-const-eval-issue-121099.rs:11:31
--> $DIR/fail-const-eval-issue-121099.rs:10:31
|
LL | global_asm!("/* {} */", const 1 / 0);
| ^^^^^ attempt to divide `1_i32` by zero

2
tests/ui/asm/generic-const.rs
View File

@ -1,8 +1,6 @@
//@ needs-asm-support
//@ build-pass
#![feature(asm_const)]
use std::arch::asm;
fn foofoo<const N: usize>() {}

2
tests/ui/asm/invalid-const-operand.rs
View File

@ -2,8 +2,6 @@
//@ ignore-nvptx64
//@ ignore-spirv
#![feature(asm_const)]
use std::arch::{asm, global_asm};
// Const operands must be integers and must be constants.

16
tests/ui/asm/invalid-const-operand.stderr
View File

@ -1,5 +1,5 @@
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/invalid-const-operand.rs:42:26
--> $DIR/invalid-const-operand.rs:40:26
|
LL | asm!("{}", const x);
| ^ non-constant value
@ -10,7 +10,7 @@ LL | const x: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/invalid-const-operand.rs:45:36
--> $DIR/invalid-const-operand.rs:43:36
|
LL | asm!("{}", const const_foo(x));
| ^ non-constant value
@ -21,7 +21,7 @@ LL | const x: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/invalid-const-operand.rs:48:36
--> $DIR/invalid-const-operand.rs:46:36
|
LL | asm!("{}", const const_bar(x));
| ^ non-constant value
@ -32,7 +32,7 @@ LL | const x: /* Type */ = 0;
| ~~~~~ ++++++++++++
error: invalid type for `const` operand
--> $DIR/invalid-const-operand.rs:14:19
--> $DIR/invalid-const-operand.rs:12:19
|
LL | global_asm!("{}", const 0f32);
| ^^^^^^----
@ -42,7 +42,7 @@ LL | global_asm!("{}", const 0f32);
= help: `const` operands must be of an integer type
error: invalid type for `const` operand
--> $DIR/invalid-const-operand.rs:16:19
--> $DIR/invalid-const-operand.rs:14:19
|
LL | global_asm!("{}", const 0 as *mut u8);
| ^^^^^^------------
@ -52,7 +52,7 @@ LL | global_asm!("{}", const 0 as *mut u8);
= help: `const` operands must be of an integer type
error: invalid type for `const` operand
--> $DIR/invalid-const-operand.rs:26:20
--> $DIR/invalid-const-operand.rs:24:20
|
LL | asm!("{}", const 0f32);
| ^^^^^^----
@ -62,7 +62,7 @@ LL | asm!("{}", const 0f32);
= help: `const` operands must be of an integer type
error: invalid type for `const` operand
--> $DIR/invalid-const-operand.rs:28:20
--> $DIR/invalid-const-operand.rs:26:20
|
LL | asm!("{}", const 0 as *mut u8);
| ^^^^^^------------
@ -72,7 +72,7 @@ LL | asm!("{}", const 0 as *mut u8);
= help: `const` operands must be of an integer type
error: invalid type for `const` operand
--> $DIR/invalid-const-operand.rs:30:20
--> $DIR/invalid-const-operand.rs:28:20
|
LL | asm!("{}", const &0);
| ^^^^^^--

2
tests/ui/asm/naked-functions.rs
View File

@ -3,7 +3,7 @@
//@ ignore-spirv
#![feature(naked_functions)]
#![feature(asm_const, asm_unwind, linkage)]
#![feature(asm_unwind, linkage)]
#![crate_type = "lib"]
use std::arch::asm;

6
tests/ui/asm/named-asm-labels.rs
View File

@ -10,7 +10,7 @@
// which causes less readable LLVM errors and in the worst cases causes ICEs
// or segfaults based on system dependent behavior and codegen flags.
#![feature(naked_functions, asm_const)]
#![feature(naked_functions)]
use std::arch::{asm, global_asm};
@ -128,6 +128,7 @@ fn main() {
// Tests usage of colons in non-label positions
asm!(":lo12:FOO"); // this is apparently valid aarch64
// is there an example that is valid x86 for this test?
asm!(":bbb nop");
@ -176,7 +177,8 @@ fn main() {
// label or LTO can cause labels to break
#[naked]
pub extern "C" fn foo() -> i32 {
unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noreturn)) } //~ ERROR avoid using named labels
unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noreturn)) }
//~^ ERROR avoid using named labels
}
// Make sure that non-naked attributes *do* still let the lint happen

44
tests/ui/asm/named-asm-labels.stderr
View File

@ -328,7 +328,7 @@ LL | ab: nop // ab: does foo
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:143:19
--> $DIR/named-asm-labels.rs:144:19
|
LL | asm!("test_{}: nop", in(reg) 10);
| ^^^^^^^
@ -338,7 +338,7 @@ LL | asm!("test_{}: nop", in(reg) 10);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:145:15
--> $DIR/named-asm-labels.rs:146:15
|
LL | asm!("test_{}: nop", const 10);
| ^^^^^^^
@ -348,7 +348,7 @@ LL | asm!("test_{}: nop", const 10);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:146:15
--> $DIR/named-asm-labels.rs:147:15
|
LL | asm!("test_{}: nop", sym main);
| ^^^^^^^
@ -358,7 +358,7 @@ LL | asm!("test_{}: nop", sym main);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:147:15
--> $DIR/named-asm-labels.rs:148:15
|
LL | asm!("{}_test: nop", const 10);
| ^^^^^^^
@ -368,7 +368,7 @@ LL | asm!("{}_test: nop", const 10);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:148:15
--> $DIR/named-asm-labels.rs:149:15
|
LL | asm!("test_{}_test: nop", const 10);
| ^^^^^^^^^^^^
@ -378,7 +378,7 @@ LL | asm!("test_{}_test: nop", const 10);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:149:15
--> $DIR/named-asm-labels.rs:150:15
|
LL | asm!("{}: nop", const 10);
| ^^
@ -388,7 +388,7 @@ LL | asm!("{}: nop", const 10);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:151:15
--> $DIR/named-asm-labels.rs:152:15
|
LL | asm!("{uwu}: nop", uwu = const 10);
| ^^^^^
@ -398,7 +398,7 @@ LL | asm!("{uwu}: nop", uwu = const 10);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:152:15
--> $DIR/named-asm-labels.rs:153:15
|
LL | asm!("{0}: nop", const 10);
| ^^^
@ -408,7 +408,7 @@ LL | asm!("{0}: nop", const 10);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:153:15
--> $DIR/named-asm-labels.rs:154:15
|
LL | asm!("{1}: nop", "/* {0} */", const 10, const 20);
| ^^^
@ -418,7 +418,7 @@ LL | asm!("{1}: nop", "/* {0} */", const 10, const 20);
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:156:14
--> $DIR/named-asm-labels.rs:157:14
|
LL | asm!(include_str!("named-asm-labels.s"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -428,7 +428,7 @@ LL | asm!(include_str!("named-asm-labels.s"));
= note: the label may be declared in the expansion of a macro
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:156:14
--> $DIR/named-asm-labels.rs:157:14
|
LL | asm!(include_str!("named-asm-labels.s"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -439,7 +439,7 @@ LL | asm!(include_str!("named-asm-labels.s"));
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:156:14
--> $DIR/named-asm-labels.rs:157:14
|
LL | asm!(include_str!("named-asm-labels.s"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -450,7 +450,7 @@ LL | asm!(include_str!("named-asm-labels.s"));
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:156:14
--> $DIR/named-asm-labels.rs:157:14
|
LL | asm!(include_str!("named-asm-labels.s"));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -461,7 +461,7 @@ LL | asm!(include_str!("named-asm-labels.s"));
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:170:19
--> $DIR/named-asm-labels.rs:171:19
|
LL | asm!("warned: nop");
| ^^^^^^
@ -469,13 +469,13 @@ LL | asm!("warned: nop");
= help: only local labels of the form `<number>:` should be used in inline asm
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
note: the lint level is defined here
--> $DIR/named-asm-labels.rs:168:16
--> $DIR/named-asm-labels.rs:169:16
|
LL | #[warn(named_asm_labels)]
| ^^^^^^^^^^^^^^^^
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:179:20
--> $DIR/named-asm-labels.rs:180:20
|
LL | unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noreturn)) }
| ^^^^^
@ -484,7 +484,7 @@ LL | unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noret
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:185:20
--> $DIR/named-asm-labels.rs:187:20
|
LL | unsafe { asm!(".Lbar: mov rax, {}; ret;", "nop", const 1, options(noreturn)) }
| ^^^^^
@ -493,7 +493,7 @@ LL | unsafe { asm!(".Lbar: mov rax, {}; ret;", "nop", const 1, options(noret
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:193:20
--> $DIR/named-asm-labels.rs:195:20
|
LL | unsafe { asm!(".Laaa: nop; ret;", options(noreturn)) }
| ^^^^^
@ -502,7 +502,7 @@ LL | unsafe { asm!(".Laaa: nop; ret;", options(noreturn)) }
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:203:24
--> $DIR/named-asm-labels.rs:205:24
|
LL | unsafe { asm!(".Lbbb: nop; ret;", options(noreturn)) }
| ^^^^^
@ -511,7 +511,7 @@ LL | unsafe { asm!(".Lbbb: nop; ret;", options(noreturn)) }
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:212:15
--> $DIR/named-asm-labels.rs:214:15
|
LL | asm!("closure1: nop");
| ^^^^^^^^
@ -520,7 +520,7 @@ LL | asm!("closure1: nop");
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:216:15
--> $DIR/named-asm-labels.rs:218:15
|
LL | asm!("closure2: nop");
| ^^^^^^^^
@ -529,7 +529,7 @@ LL | asm!("closure2: nop");
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:226:19
--> $DIR/named-asm-labels.rs:228:19
|
LL | asm!("closure3: nop");
| ^^^^^^^^

2
tests/ui/asm/parse-error.rs
View File

@ -1,7 +1,5 @@
//@ needs-asm-support
#![feature(asm_const)]
use std::arch::{asm, global_asm};
fn main() {

144
tests/ui/asm/parse-error.stderr
View File

@ -1,167 +1,167 @@
error: requires at least a template string argument
--> $DIR/parse-error.rs:11:9
--> $DIR/parse-error.rs:9:9
|
LL | asm!();
| ^^^^^^
error: asm template must be a string literal
--> $DIR/parse-error.rs:13:14
--> $DIR/parse-error.rs:11:14
|
LL | asm!(foo);
| ^^^
error: expected token: `,`
--> $DIR/parse-error.rs:15:19
--> $DIR/parse-error.rs:13:19
|
LL | asm!("{}" foo);
| ^^^ expected `,`
error: expected operand, clobber_abi, options, or additional template string
--> $DIR/parse-error.rs:17:20
--> $DIR/parse-error.rs:15:20
|
LL | asm!("{}", foo);
| ^^^ expected operand, clobber_abi, options, or additional template string
error: expected `(`, found `foo`
--> $DIR/parse-error.rs:19:23
--> $DIR/parse-error.rs:17:23
|
LL | asm!("{}", in foo);
| ^^^ expected `(`
error: expected `)`, found `foo`
--> $DIR/parse-error.rs:21:27
--> $DIR/parse-error.rs:19:27
|
LL | asm!("{}", in(reg foo));
| ^^^ expected `)`
error: expected expression, found end of macro arguments
--> $DIR/parse-error.rs:23:27
--> $DIR/parse-error.rs:21:27
|
LL | asm!("{}", in(reg));
| ^ expected expression
error: expected register class or explicit register
--> $DIR/parse-error.rs:25:26
--> $DIR/parse-error.rs:23:26
|
LL | asm!("{}", inout(=) foo => bar);
| ^
error: expected expression, found end of macro arguments
--> $DIR/parse-error.rs:27:37
--> $DIR/parse-error.rs:25:37
|
LL | asm!("{}", inout(reg) foo =>);
| ^ expected expression
error: expected one of `!`, `,`, `.`, `::`, `?`, `{`, or an operator, found `=>`
--> $DIR/parse-error.rs:29:32
--> $DIR/parse-error.rs:27:32
|
LL | asm!("{}", in(reg) foo => bar);
| ^^ expected one of 7 possible tokens
error: expected a path for argument to `sym`
--> $DIR/parse-error.rs:31:24
--> $DIR/parse-error.rs:29:24
|
LL | asm!("{}", sym foo + bar);
| ^^^^^^^^^
error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
--> $DIR/parse-error.rs:33:26
--> $DIR/parse-error.rs:31:26
|
LL | asm!("", options(foo));
| ^^^ expected one of 10 possible tokens
error: expected one of `)` or `,`, found `foo`
--> $DIR/parse-error.rs:35:32
--> $DIR/parse-error.rs:33:32
|
LL | asm!("", options(nomem foo));
| ^^^ expected one of `)` or `,`
error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
--> $DIR/parse-error.rs:37:33
--> $DIR/parse-error.rs:35:33
|
LL | asm!("", options(nomem, foo));
| ^^^ expected one of 10 possible tokens
error: at least one abi must be provided as an argument to `clobber_abi`
--> $DIR/parse-error.rs:44:30
--> $DIR/parse-error.rs:42:30
|
LL | asm!("", clobber_abi());
| ^
error: expected string literal
--> $DIR/parse-error.rs:46:30
--> $DIR/parse-error.rs:44:30
|
LL | asm!("", clobber_abi(foo));
| ^^^ not a string literal
error: expected one of `)` or `,`, found `foo`
--> $DIR/parse-error.rs:48:34
--> $DIR/parse-error.rs:46:34
|
LL | asm!("", clobber_abi("C" foo));
| ^^^ expected one of `)` or `,`
error: expected string literal
--> $DIR/parse-error.rs:50:35
--> $DIR/parse-error.rs:48:35
|
LL | asm!("", clobber_abi("C", foo));
| ^^^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:52:30
--> $DIR/parse-error.rs:50:30
|
LL | asm!("", clobber_abi(1));
| ^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:54:30
--> $DIR/parse-error.rs:52:30
|
LL | asm!("", clobber_abi(()));
| ^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:56:30
--> $DIR/parse-error.rs:54:30
|
LL | asm!("", clobber_abi(uwu));
| ^^^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:58:30
--> $DIR/parse-error.rs:56:30
|
LL | asm!("", clobber_abi({}));
| ^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:60:30
--> $DIR/parse-error.rs:58:30
|
LL | asm!("", clobber_abi(loop {}));
| ^^^^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:62:30
--> $DIR/parse-error.rs:60:30
|
LL | asm!("", clobber_abi(if));
| ^^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:64:30
--> $DIR/parse-error.rs:62:30
|
LL | asm!("", clobber_abi(do));
| ^^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:66:30
--> $DIR/parse-error.rs:64:30
|
LL | asm!("", clobber_abi(<));
| ^ not a string literal
error: expected string literal
--> $DIR/parse-error.rs:68:30
--> $DIR/parse-error.rs:66:30
|
LL | asm!("", clobber_abi(.));
| ^ not a string literal
error: duplicate argument named `a`
--> $DIR/parse-error.rs:76:36
--> $DIR/parse-error.rs:74:36
|
LL | asm!("{a}", a = const foo, a = const bar);
| ------------- ^^^^^^^^^^^^^ duplicate argument
@ -169,7 +169,7 @@ LL | asm!("{a}", a = const foo, a = const bar);
| previously here
error: argument never used
--> $DIR/parse-error.rs:76:36
--> $DIR/parse-error.rs:74:36
|
LL | asm!("{a}", a = const foo, a = const bar);
| ^^^^^^^^^^^^^ argument never used
@ -177,19 +177,19 @@ LL | asm!("{a}", a = const foo, a = const bar);
= help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `""`
--> $DIR/parse-error.rs:82:29
--> $DIR/parse-error.rs:80:29
|
LL | asm!("", options(), "");
| ^^ expected one of 10 possible tokens
error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `"{}"`
--> $DIR/parse-error.rs:84:33
--> $DIR/parse-error.rs:82:33
|
LL | asm!("{}", in(reg) foo, "{}", out(reg) foo);
| ^^^^ expected one of 10 possible tokens
error: asm template must be a string literal
--> $DIR/parse-error.rs:86:14
--> $DIR/parse-error.rs:84:14
|
LL | asm!(format!("{{{}}}", 0), in(reg) foo);
| ^^^^^^^^^^^^^^^^^^^^
@ -197,7 +197,7 @@ LL | asm!(format!("{{{}}}", 0), in(reg) foo);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error: asm template must be a string literal
--> $DIR/parse-error.rs:88:21
--> $DIR/parse-error.rs:86:21
|
LL | asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
| ^^^^^^^^^^^^^^^^^^^^
@ -205,139 +205,139 @@ LL | asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error: _ cannot be used for input operands
--> $DIR/parse-error.rs:90:28
--> $DIR/parse-error.rs:88:28
|
LL | asm!("{}", in(reg) _);
| ^
error: _ cannot be used for input operands
--> $DIR/parse-error.rs:92:31
--> $DIR/parse-error.rs:90:31
|
LL | asm!("{}", inout(reg) _);
| ^
error: _ cannot be used for input operands
--> $DIR/parse-error.rs:94:35
--> $DIR/parse-error.rs:92:35
|
LL | asm!("{}", inlateout(reg) _);
| ^
error: requires at least a template string argument
--> $DIR/parse-error.rs:101:1
--> $DIR/parse-error.rs:99:1
|
LL | global_asm!();
| ^^^^^^^^^^^^^
error: asm template must be a string literal
--> $DIR/parse-error.rs:103:13
--> $DIR/parse-error.rs:101:13
|
LL | global_asm!(FOO);
| ^^^
error: expected token: `,`
--> $DIR/parse-error.rs:105:18
--> $DIR/parse-error.rs:103:18
|
LL | global_asm!("{}" FOO);
| ^^^ expected `,`
error: expected operand, options, or additional template string
--> $DIR/parse-error.rs:107:19
--> $DIR/parse-error.rs:105:19
|
LL | global_asm!("{}", FOO);
| ^^^ expected operand, options, or additional template string
error: expected expression, found end of macro arguments
--> $DIR/parse-error.rs:109:24
--> $DIR/parse-error.rs:107:24
|
LL | global_asm!("{}", const);
| ^ expected expression
error: expected one of `,`, `.`, `?`, or an operator, found `FOO`
--> $DIR/parse-error.rs:111:30
--> $DIR/parse-error.rs:109:30
|
LL | global_asm!("{}", const(reg) FOO);
| ^^^ expected one of `,`, `.`, `?`, or an operator
error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
--> $DIR/parse-error.rs:113:25
--> $DIR/parse-error.rs:111:25
|
LL | global_asm!("", options(FOO));
| ^^^ expected one of `)`, `att_syntax`, or `raw`
error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
--> $DIR/parse-error.rs:115:25
--> $DIR/parse-error.rs:113:25
|
LL | global_asm!("", options(FOO,));
| ^^^ expected one of `)`, `att_syntax`, or `raw`
error: the `nomem` option cannot be used with `global_asm!`
--> $DIR/parse-error.rs:117:25
--> $DIR/parse-error.rs:115:25
|
LL | global_asm!("", options(nomem FOO));
| ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
error: expected one of `)` or `,`, found `FOO`
--> $DIR/parse-error.rs:117:31
--> $DIR/parse-error.rs:115:31
|
LL | global_asm!("", options(nomem FOO));
| ^^^ expected one of `)` or `,`
error: the `nomem` option cannot be used with `global_asm!`
--> $DIR/parse-error.rs:120:25
--> $DIR/parse-error.rs:118:25
|
LL | global_asm!("", options(nomem, FOO));
| ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
--> $DIR/parse-error.rs:120:32
--> $DIR/parse-error.rs:118:32
|
LL | global_asm!("", options(nomem, FOO));
| ^^^ expected one of `)`, `att_syntax`, or `raw`
error: expected string literal
--> $DIR/parse-error.rs:124:29
--> $DIR/parse-error.rs:122:29
|
LL | global_asm!("", clobber_abi(FOO));
| ^^^ not a string literal
error: expected one of `)` or `,`, found `FOO`
--> $DIR/parse-error.rs:126:33
--> $DIR/parse-error.rs:124:33
|
LL | global_asm!("", clobber_abi("C" FOO));
| ^^^ expected one of `)` or `,`
error: expected string literal
--> $DIR/parse-error.rs:128:34
--> $DIR/parse-error.rs:126:34
|
LL | global_asm!("", clobber_abi("C", FOO));
| ^^^ not a string literal
error: `clobber_abi` cannot be used with `global_asm!`
--> $DIR/parse-error.rs:130:19
--> $DIR/parse-error.rs:128:19
|
LL | global_asm!("{}", clobber_abi("C"), const FOO);
| ^^^^^^^^^^^^^^^^
error: `clobber_abi` cannot be used with `global_asm!`
--> $DIR/parse-error.rs:132:28
--> $DIR/parse-error.rs:130:28
|
LL | global_asm!("", options(), clobber_abi("C"));
| ^^^^^^^^^^^^^^^^
error: `clobber_abi` cannot be used with `global_asm!`
--> $DIR/parse-error.rs:134:30
--> $DIR/parse-error.rs:132:30
|
LL | global_asm!("{}", options(), clobber_abi("C"), const FOO);
| ^^^^^^^^^^^^^^^^
error: `clobber_abi` cannot be used with `global_asm!`
--> $DIR/parse-error.rs:136:17
--> $DIR/parse-error.rs:134:17
|
LL | global_asm!("", clobber_abi("C"), clobber_abi("C"));
| ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
error: duplicate argument named `a`
--> $DIR/parse-error.rs:138:35
--> $DIR/parse-error.rs:136:35
|
LL | global_asm!("{a}", a = const FOO, a = const BAR);
| ------------- ^^^^^^^^^^^^^ duplicate argument
@ -345,7 +345,7 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
| previously here
error: argument never used
--> $DIR/parse-error.rs:138:35
--> $DIR/parse-error.rs:136:35
|
LL | global_asm!("{a}", a = const FOO, a = const BAR);
| ^^^^^^^^^^^^^ argument never used
@ -353,19 +353,19 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
= help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `""`
--> $DIR/parse-error.rs:141:28
--> $DIR/parse-error.rs:139:28
|
LL | global_asm!("", options(), "");
| ^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `"{}"`
--> $DIR/parse-error.rs:143:30
--> $DIR/parse-error.rs:141:30
|
LL | global_asm!("{}", const FOO, "{}", const FOO);
| ^^^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
error: asm template must be a string literal
--> $DIR/parse-error.rs:145:13
--> $DIR/parse-error.rs:143:13
|
LL | global_asm!(format!("{{{}}}", 0), const FOO);
| ^^^^^^^^^^^^^^^^^^^^
@ -373,7 +373,7 @@ LL | global_asm!(format!("{{{}}}", 0), const FOO);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error: asm template must be a string literal
--> $DIR/parse-error.rs:147:20
--> $DIR/parse-error.rs:145:20
|
LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
| ^^^^^^^^^^^^^^^^^^^^
@ -381,43 +381,43 @@ LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
= note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
error: the `in` operand cannot be used with `global_asm!`
--> $DIR/parse-error.rs:150:19
--> $DIR/parse-error.rs:148:19
|
LL | global_asm!("{}", in(reg));
| ^^ the `in` operand is not meaningful for global-scoped inline assembly, remove it
error: the `out` operand cannot be used with `global_asm!`
--> $DIR/parse-error.rs:152:19
--> $DIR/parse-error.rs:150:19
|
LL | global_asm!("{}", out(reg));
| ^^^ the `out` operand is not meaningful for global-scoped inline assembly, remove it
error: the `lateout` operand cannot be used with `global_asm!`
--> $DIR/parse-error.rs:154:19
--> $DIR/parse-error.rs:152:19
|
LL | global_asm!("{}", lateout(reg));
| ^^^^^^^ the `lateout` operand is not meaningful for global-scoped inline assembly, remove it
error: the `inout` operand cannot be used with `global_asm!`
--> $DIR/parse-error.rs:156:19
--> $DIR/parse-error.rs:154:19
|
LL | global_asm!("{}", inout(reg));
| ^^^^^ the `inout` operand is not meaningful for global-scoped inline assembly, remove it
error: the `inlateout` operand cannot be used with `global_asm!`
--> $DIR/parse-error.rs:158:19
--> $DIR/parse-error.rs:156:19
|
LL | global_asm!("{}", inlateout(reg));
| ^^^^^^^^^ the `inlateout` operand is not meaningful for global-scoped inline assembly, remove it
error: the `label` operand cannot be used with `global_asm!`
--> $DIR/parse-error.rs:160:19
--> $DIR/parse-error.rs:158:19
|
LL | global_asm!("{}", label(reg));
| ^^^^^ the `label` operand is not meaningful for global-scoped inline assembly, remove it
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:39:37
--> $DIR/parse-error.rs:37:37
|
LL | asm!("{}", options(), const foo);
| ^^^ non-constant value
@ -428,7 +428,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:71:44
--> $DIR/parse-error.rs:69:44
|
LL | asm!("{}", clobber_abi("C"), const foo);
| ^^^ non-constant value
@ -439,7 +439,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:74:55
--> $DIR/parse-error.rs:72:55
|
LL | asm!("{}", options(), clobber_abi("C"), const foo);
| ^^^ non-constant value
@ -450,7 +450,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:76:31
--> $DIR/parse-error.rs:74:31
|
LL | asm!("{a}", a = const foo, a = const bar);
| ^^^ non-constant value
@ -461,7 +461,7 @@ LL | const foo: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/parse-error.rs:76:46
--> $DIR/parse-error.rs:74:46
|
LL | asm!("{a}", a = const foo, a = const bar);
| ^^^ non-constant value

2
tests/ui/asm/type-check-1.rs
View File

@ -2,8 +2,6 @@
//@ ignore-nvptx64
//@ ignore-spirv
#![feature(asm_const)]
use std::arch::{asm, global_asm};
fn main() {

16
tests/ui/asm/type-check-1.stderr
View File

@ -1,17 +1,17 @@
error: invalid asm output
--> $DIR/type-check-1.rs:14:29
--> $DIR/type-check-1.rs:12:29
|
LL | asm!("{}", out(reg) 1 + 2);
| ^^^^^ cannot assign to this expression
error: invalid asm output
--> $DIR/type-check-1.rs:16:31
--> $DIR/type-check-1.rs:14:31
|
LL | asm!("{}", inout(reg) 1 + 2);
| ^^^^^ cannot assign to this expression
error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
--> $DIR/type-check-1.rs:22:28
--> $DIR/type-check-1.rs:20:28
|
LL | asm!("{}", in(reg) v[..]);
| ^^^^^ doesn't have a size known at compile-time
@ -20,7 +20,7 @@ LL | asm!("{}", in(reg) v[..]);
= note: all inline asm arguments must have a statically known size
error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
--> $DIR/type-check-1.rs:25:29
--> $DIR/type-check-1.rs:23:29
|
LL | asm!("{}", out(reg) v[..]);
| ^^^^^ doesn't have a size known at compile-time
@ -29,7 +29,7 @@ LL | asm!("{}", out(reg) v[..]);
= note: all inline asm arguments must have a statically known size
error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
--> $DIR/type-check-1.rs:28:31
--> $DIR/type-check-1.rs:26:31
|
LL | asm!("{}", inout(reg) v[..]);
| ^^^^^ doesn't have a size known at compile-time
@ -38,7 +38,7 @@ LL | asm!("{}", inout(reg) v[..]);
= note: all inline asm arguments must have a statically known size
error: cannot use value of type `[u64]` for inline assembly
--> $DIR/type-check-1.rs:22:28
--> $DIR/type-check-1.rs:20:28
|
LL | asm!("{}", in(reg) v[..]);
| ^^^^^
@ -46,7 +46,7 @@ LL | asm!("{}", in(reg) v[..]);
= note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
error: cannot use value of type `[u64]` for inline assembly
--> $DIR/type-check-1.rs:25:29
--> $DIR/type-check-1.rs:23:29
|
LL | asm!("{}", out(reg) v[..]);
| ^^^^^
@ -54,7 +54,7 @@ LL | asm!("{}", out(reg) v[..]);
= note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
error: cannot use value of type `[u64]` for inline assembly
--> $DIR/type-check-1.rs:28:31
--> $DIR/type-check-1.rs:26:31
|
LL | asm!("{}", inout(reg) v[..]);
| ^^^^^

2
tests/ui/asm/x86_64/bad-reg.rs
View File

@ -1,8 +1,6 @@
//@ only-x86_64
//@ compile-flags: -C target-feature=+avx2
#![feature(asm_const)]
use std::arch::asm;
fn main() {

60
tests/ui/asm/x86_64/bad-reg.stderr
View File

@ -1,17 +1,17 @@
error: invalid register class `foo`: unknown register class
--> $DIR/bad-reg.rs:14:20
--> $DIR/bad-reg.rs:12:20
|
LL | asm!("{}", in(foo) foo);
| ^^^^^^^^^^^
error: invalid register `foo`: unknown register
--> $DIR/bad-reg.rs:16:18
--> $DIR/bad-reg.rs:14:18
|
LL | asm!("", in("foo") foo);
| ^^^^^^^^^^^^^
error: invalid asm template modifier for this register class
--> $DIR/bad-reg.rs:18:15
--> $DIR/bad-reg.rs:16:15
|
LL | asm!("{:z}", in(reg) foo);
| ^^^^ ----------- argument
@ -21,7 +21,7 @@ LL | asm!("{:z}", in(reg) foo);
= note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, `r`
error: invalid asm template modifier for this register class
--> $DIR/bad-reg.rs:20:15
--> $DIR/bad-reg.rs:18:15
|
LL | asm!("{:r}", in(xmm_reg) foo);
| ^^^^ --------------- argument
@ -31,7 +31,7 @@ LL | asm!("{:r}", in(xmm_reg) foo);
= note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, `z`
error: asm template modifiers are not allowed for `const` arguments
--> $DIR/bad-reg.rs:22:15
--> $DIR/bad-reg.rs:20:15
|
LL | asm!("{:a}", const 0);
| ^^^^ ------- argument
@ -39,7 +39,7 @@ LL | asm!("{:a}", const 0);
| template modifier
error: asm template modifiers are not allowed for `sym` arguments
--> $DIR/bad-reg.rs:24:15
--> $DIR/bad-reg.rs:22:15
|
LL | asm!("{:a}", sym main);
| ^^^^ -------- argument
@ -47,67 +47,67 @@ LL | asm!("{:a}", sym main);
| template modifier
error: invalid register `ebp`: the frame pointer cannot be used as an operand for inline asm
--> $DIR/bad-reg.rs:26:18
--> $DIR/bad-reg.rs:24:18
|
LL | asm!("", in("ebp") foo);
| ^^^^^^^^^^^^^
error: invalid register `rsp`: the stack pointer cannot be used as an operand for inline asm
--> $DIR/bad-reg.rs:28:18
--> $DIR/bad-reg.rs:26:18
|
LL | asm!("", in("rsp") foo);
| ^^^^^^^^^^^^^
error: invalid register `ip`: the instruction pointer cannot be used as an operand for inline asm
--> $DIR/bad-reg.rs:30:18
--> $DIR/bad-reg.rs:28:18
|
LL | asm!("", in("ip") foo);
| ^^^^^^^^^^^^
error: register class `x87_reg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:33:18
--> $DIR/bad-reg.rs:31:18
|
LL | asm!("", in("st(2)") foo);
| ^^^^^^^^^^^^^^^
error: register class `mmx_reg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:36:18
--> $DIR/bad-reg.rs:34:18
|
LL | asm!("", in("mm0") foo);
| ^^^^^^^^^^^^^
error: register class `kreg0` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:39:18
--> $DIR/bad-reg.rs:37:18
|
LL | asm!("", in("k0") foo);
| ^^^^^^^^^^^^
error: register class `x87_reg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:44:20
--> $DIR/bad-reg.rs:42:20
|
LL | asm!("{}", in(x87_reg) foo);
| ^^^^^^^^^^^^^^^
error: register class `mmx_reg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:47:20
--> $DIR/bad-reg.rs:45:20
|
LL | asm!("{}", in(mmx_reg) foo);
| ^^^^^^^^^^^^^^^
error: register class `x87_reg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:50:20
--> $DIR/bad-reg.rs:48:20
|
LL | asm!("{}", out(x87_reg) _);
| ^^^^^^^^^^^^^^
error: register class `mmx_reg` can only be used as a clobber, not as an input or output
--> $DIR/bad-reg.rs:52:20
--> $DIR/bad-reg.rs:50:20
|
LL | asm!("{}", out(mmx_reg) _);
| ^^^^^^^^^^^^^^
error: register `al` conflicts with register `eax`
--> $DIR/bad-reg.rs:58:33
--> $DIR/bad-reg.rs:56:33
|
LL | asm!("", in("eax") foo, in("al") bar);
| ------------- ^^^^^^^^^^^^ register `al`
@ -115,7 +115,7 @@ LL | asm!("", in("eax") foo, in("al") bar);
| register `eax`
error: register `rax` conflicts with register `rax`
--> $DIR/bad-reg.rs:61:33
--> $DIR/bad-reg.rs:59:33
|
LL | asm!("", in("rax") foo, out("rax") bar);
| ------------- ^^^^^^^^^^^^^^ register `rax`
@ -123,13 +123,13 @@ LL | asm!("", in("rax") foo, out("rax") bar);
| register `rax`
|
help: use `lateout` instead of `out` to avoid conflict
--> $DIR/bad-reg.rs:61:18
--> $DIR/bad-reg.rs:59:18
|
LL | asm!("", in("rax") foo, out("rax") bar);
| ^^^^^^^^^^^^^
error: register `ymm0` conflicts with register `xmm0`
--> $DIR/bad-reg.rs:66:34
--> $DIR/bad-reg.rs:64:34
|
LL | asm!("", in("xmm0") foo, in("ymm0") bar);
| -------------- ^^^^^^^^^^^^^^ register `ymm0`
@ -137,7 +137,7 @@ LL | asm!("", in("xmm0") foo, in("ymm0") bar);
| register `xmm0`
error: register `ymm0` conflicts with register `xmm0`
--> $DIR/bad-reg.rs:68:34
--> $DIR/bad-reg.rs:66:34
|
LL | asm!("", in("xmm0") foo, out("ymm0") bar);
| -------------- ^^^^^^^^^^^^^^^ register `ymm0`
@ -145,13 +145,13 @@ LL | asm!("", in("xmm0") foo, out("ymm0") bar);
| register `xmm0`
|
help: use `lateout` instead of `out` to avoid conflict
--> $DIR/bad-reg.rs:68:18
--> $DIR/bad-reg.rs:66:18
|
LL | asm!("", in("xmm0") foo, out("ymm0") bar);
| ^^^^^^^^^^^^^^
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:33:30
--> $DIR/bad-reg.rs:31:30
|
LL | asm!("", in("st(2)") foo);
| ^^^
@ -159,7 +159,7 @@ LL | asm!("", in("st(2)") foo);
= note: register class `x87_reg` supports these types:
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:36:28
--> $DIR/bad-reg.rs:34:28
|
LL | asm!("", in("mm0") foo);
| ^^^
@ -167,7 +167,7 @@ LL | asm!("", in("mm0") foo);
= note: register class `mmx_reg` supports these types:
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:39:27
--> $DIR/bad-reg.rs:37:27
|
LL | asm!("", in("k0") foo);
| ^^^
@ -175,7 +175,7 @@ LL | asm!("", in("k0") foo);
= note: register class `kreg0` supports these types:
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:44:32
--> $DIR/bad-reg.rs:42:32
|
LL | asm!("{}", in(x87_reg) foo);
| ^^^
@ -183,7 +183,7 @@ LL | asm!("{}", in(x87_reg) foo);
= note: register class `x87_reg` supports these types:
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:47:32
--> $DIR/bad-reg.rs:45:32
|
LL | asm!("{}", in(mmx_reg) foo);
| ^^^
@ -191,7 +191,7 @@ LL | asm!("{}", in(mmx_reg) foo);
= note: register class `mmx_reg` supports these types:
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:58:42
--> $DIR/bad-reg.rs:56:42
|
LL | asm!("", in("eax") foo, in("al") bar);
| ^^^
@ -199,7 +199,7 @@ LL | asm!("", in("eax") foo, in("al") bar);
= note: register class `reg_byte` supports these types: i8
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:63:27
--> $DIR/bad-reg.rs:61:27
|
LL | asm!("", in("al") foo, lateout("al") bar);
| ^^^
@ -207,7 +207,7 @@ LL | asm!("", in("al") foo, lateout("al") bar);
= note: register class `reg_byte` supports these types: i8
error: type `i32` cannot be used with this register class
--> $DIR/bad-reg.rs:63:46
--> $DIR/bad-reg.rs:61:46
|
LL | asm!("", in("al") foo, lateout("al") bar);
| ^^^

2
tests/ui/asm/x86_64/const.rs
View File

@ -2,8 +2,6 @@
//@ run-pass
//@ needs-asm-support
#![feature(asm_const)]
use std::arch::{asm, global_asm};
fn const_generic<const X: usize>() -> usize {

2
tests/ui/asm/x86_64/type-check-3.rs
View File

@ -1,8 +1,6 @@
//@ only-x86_64
//@ compile-flags: -C target-feature=+avx512f
#![feature(asm_const)]
use std::arch::{asm, global_asm};
use std::arch::x86_64::{_mm256_setzero_ps, _mm_setzero_ps};

26
tests/ui/asm/x86_64/type-check-3.stderr
View File

@ -1,5 +1,5 @@
error: type `i128` cannot be used with this register class
--> $DIR/type-check-3.rs:14:28
--> $DIR/type-check-3.rs:12:28
|
LL | asm!("{}", in(reg) 0i128);
| ^^^^^
@ -7,7 +7,7 @@ LL | asm!("{}", in(reg) 0i128);
= note: register class `reg` supports these types: i16, i32, i64, f16, f32, f64
error: type `__m128` cannot be used with this register class
--> $DIR/type-check-3.rs:16:28
--> $DIR/type-check-3.rs:14:28
|
LL | asm!("{}", in(reg) _mm_setzero_ps());
| ^^^^^^^^^^^^^^^^
@ -15,7 +15,7 @@ LL | asm!("{}", in(reg) _mm_setzero_ps());
= note: register class `reg` supports these types: i16, i32, i64, f16, f32, f64
error: type `__m256` cannot be used with this register class
--> $DIR/type-check-3.rs:18:28
--> $DIR/type-check-3.rs:16:28
|
LL | asm!("{}", in(reg) _mm256_setzero_ps());
| ^^^^^^^^^^^^^^^^^^^
@ -23,7 +23,7 @@ LL | asm!("{}", in(reg) _mm256_setzero_ps());
= note: register class `reg` supports these types: i16, i32, i64, f16, f32, f64
error: type `u8` cannot be used with this register class
--> $DIR/type-check-3.rs:20:32
--> $DIR/type-check-3.rs:18:32
|
LL | asm!("{}", in(xmm_reg) 0u8);
| ^^^
@ -31,7 +31,7 @@ LL | asm!("{}", in(xmm_reg) 0u8);
= note: register class `xmm_reg` supports these types: i32, i64, f16, f32, f64, f128, i8x16, i16x8, i32x4, i64x2, f16x8, f32x4, f64x2
error: `avx512bw` target feature is not enabled
--> $DIR/type-check-3.rs:29:29
--> $DIR/type-check-3.rs:27:29
|
LL | asm!("{}", in(kreg) 0u64);
| ^^^^
@ -39,7 +39,7 @@ LL | asm!("{}", in(kreg) 0u64);
= note: this is required to use type `u64` with register class `kreg`
warning: formatting may not be suitable for sub-register argument
--> $DIR/type-check-3.rs:34:15
--> $DIR/type-check-3.rs:32:15
|
LL | asm!("{0} {0}", in(reg) 0i16);
| ^^^ ^^^ ---- for this argument
@ -49,7 +49,7 @@ LL | asm!("{0} {0}", in(reg) 0i16);
= note: `#[warn(asm_sub_register)]` on by default
warning: formatting may not be suitable for sub-register argument
--> $DIR/type-check-3.rs:36:15
--> $DIR/type-check-3.rs:34:15
|
LL | asm!("{0} {0:x}", in(reg) 0i16);
| ^^^ ---- for this argument
@ -58,7 +58,7 @@ LL | asm!("{0} {0:x}", in(reg) 0i16);
= help: or use `{0:r}` to keep the default formatting of `rax` (for 64-bit values)
warning: formatting may not be suitable for sub-register argument
--> $DIR/type-check-3.rs:38:15
--> $DIR/type-check-3.rs:36:15
|
LL | asm!("{}", in(reg) 0i32);
| ^^ ---- for this argument
@ -67,7 +67,7 @@ LL | asm!("{}", in(reg) 0i32);
= help: or use `{0:r}` to keep the default formatting of `rax` (for 64-bit values)
warning: formatting may not be suitable for sub-register argument
--> $DIR/type-check-3.rs:41:15
--> $DIR/type-check-3.rs:39:15
|
LL | asm!("{}", in(ymm_reg) 0i64);
| ^^ ---- for this argument
@ -76,7 +76,7 @@ LL | asm!("{}", in(ymm_reg) 0i64);
= help: or use `{0:y}` to keep the default formatting of `ymm0` (for 256-bit values)
error: type `i8` cannot be used with this register class
--> $DIR/type-check-3.rs:52:28
--> $DIR/type-check-3.rs:50:28
|
LL | asm!("{}", in(reg) 0i8);
| ^^^
@ -85,7 +85,7 @@ LL | asm!("{}", in(reg) 0i8);
= help: consider using the `reg_byte` register class instead
error: incompatible types for asm inout argument
--> $DIR/type-check-3.rs:64:33
--> $DIR/type-check-3.rs:62:33
|
LL | asm!("{:r}", inout(reg) 0u32 => val_f32);
| ^^^^ ^^^^^^^ type `f32`
@ -95,7 +95,7 @@ LL | asm!("{:r}", inout(reg) 0u32 => val_f32);
= note: asm inout arguments must have the same type, unless they are both pointers or integers of the same size
error: incompatible types for asm inout argument
--> $DIR/type-check-3.rs:66:33
--> $DIR/type-check-3.rs:64:33
|
LL | asm!("{:r}", inout(reg) 0u32 => val_ptr);
| ^^^^ ^^^^^^^ type `*mut u8`
@ -105,7 +105,7 @@ LL | asm!("{:r}", inout(reg) 0u32 => val_ptr);
= note: asm inout arguments must have the same type, unless they are both pointers or integers of the same size
error: incompatible types for asm inout argument
--> $DIR/type-check-3.rs:68:33
--> $DIR/type-check-3.rs:66:33
|
LL | asm!("{:r}", inout(reg) main => val_u32);
| ^^^^ ^^^^^^^ type `u32`

2
tests/ui/asm/x86_64/type-check-4.rs
View File

@ -1,8 +1,6 @@
//@ only-x86_64
//@ compile-flags: -C target-feature=+avx512f
#![feature(asm_const)]
use std::arch::{asm, global_asm};
use std::arch::x86_64::{_mm256_setzero_ps, _mm_setzero_ps};

6
tests/ui/asm/x86_64/type-check-4.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: referencing statics in constants is unstable
--> $DIR/type-check-4.rs:21:25
--> $DIR/type-check-4.rs:19:25
|
LL | global_asm!("{}", const S);
| ^
@ -11,7 +11,7 @@ LL | global_asm!("{}", const S);
= help: to fix this, the value can be extracted to a `const` and then used.
error[E0658]: referencing statics in constants is unstable
--> $DIR/type-check-4.rs:24:35
--> $DIR/type-check-4.rs:22:35
|
LL | global_asm!("{}", const const_foo(S));
| ^
@ -23,7 +23,7 @@ LL | global_asm!("{}", const const_foo(S));
= help: to fix this, the value can be extracted to a `const` and then used.
error[E0658]: referencing statics in constants is unstable
--> $DIR/type-check-4.rs:27:35
--> $DIR/type-check-4.rs:25:35
|
LL | global_asm!("{}", const const_bar(S));
| ^

2
tests/ui/asm/x86_64/x86_64_parse_error.rs
View File

@ -1,7 +1,5 @@
//@ only-x86_64
#![feature(asm_const)]
use std::arch::asm;
fn main() {

28
tests/ui/asm/x86_64/x86_64_parse_error.stderr
View File

@ -1,17 +1,28 @@
error: explicit register arguments cannot have names
--> $DIR/x86_64_parse_error.rs:11:18
--> $DIR/x86_64_parse_error.rs:9:18
|
LL | asm!("", a = in("eax") foo);
| ^^^^^^^^^^^^^^^^^
error: positional arguments cannot follow named arguments or explicit register arguments
--> $DIR/x86_64_parse_error.rs:17:36
--> $DIR/x86_64_parse_error.rs:15:36
|
LL | asm!("{1}", in("eax") foo, const bar);
| ------------- ^^^^^^^^^ positional argument
| |
| explicit register argument
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/x86_64_parse_error.rs:11:46
|
LL | asm!("{a}", in("eax") foo, a = const bar);
| ^^^ non-constant value
|
help: consider using `const` instead of `let`
|
LL | const bar: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/x86_64_parse_error.rs:13:46
|
@ -24,18 +35,7 @@ LL | const bar: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/x86_64_parse_error.rs:15:46
|
LL | asm!("{a}", in("eax") foo, a = const bar);
| ^^^ non-constant value
|
help: consider using `const` instead of `let`
|
LL | const bar: /* Type */ = 0;
| ~~~~~ ++++++++++++
error[E0435]: attempt to use a non-constant value in a constant
--> $DIR/x86_64_parse_error.rs:17:42
--> $DIR/x86_64_parse_error.rs:15:42
|
LL | asm!("{1}", in("eax") foo, const bar);
| ^^^ non-constant value

16
tests/ui/feature-gates/feature-gate-asm_const.rs
View File

@ -1,16 +0,0 @@
//@ only-x86_64
use std::arch::asm;
unsafe fn foo<const N: usize>() {
asm!("mov eax, {}", const N + 1);
//~^ ERROR const operands for inline assembly are unstable
}
fn main() {
unsafe {
foo::<0>();
asm!("mov eax, {}", const 123);
//~^ ERROR const operands for inline assembly are unstable
}
}

23
tests/ui/feature-gates/feature-gate-asm_const.stderr
View File

@ -1,23 +0,0 @@
error[E0658]: const operands for inline assembly are unstable
--> $DIR/feature-gate-asm_const.rs:6:25
|
LL | asm!("mov eax, {}", const N + 1);
| ^^^^^^^^^^^
|
= note: see issue #93332 <https://github.com/rust-lang/rust/issues/93332> for more information
= help: add `#![feature(asm_const)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: const operands for inline assembly are unstable
--> $DIR/feature-gate-asm_const.rs:13:29
|
LL | asm!("mov eax, {}", const 123);
| ^^^^^^^^^
|
= note: see issue #93332 <https://github.com/rust-lang/rust/issues/93332> for more information
= help: add `#![feature(asm_const)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0658`.