apply cfg everywhere except for the first template element

Author: folkertdev

compiler/rustc_builtin_macros/src/asm.rs

@@ -182,8 +182,10 @@ pub fn parse_asm_args<'a>(
 
         // Parse options
         if p.eat_keyword(exp!(Options)) {
-            parse_options(p, &mut args, asm_macro)?;
-            allow_templates = false;
+            parse_options(p, &mut args, asm_macro, is_configured_out)?;
+            if !is_configured_out {
+                allow_templates = false;
+            }
             continue;
         }
 
@@ -194,7 +196,9 @@ pub fn parse_asm_args<'a>(
             let (ident, _) = p.token.ident().unwrap();
             p.bump();
             p.expect(exp!(Eq))?;
-            allow_templates = false;
+            if !is_configured_out {
+                allow_templates = false;
+            }
             Some(ident.name)
         } else {
             None
@@ -265,6 +269,11 @@ pub fn parse_asm_args<'a>(
             ast::InlineAsmOperand::Sym { sym }
         } else if allow_templates {
             let template = p.parse_expr()?;
+
+            if is_configured_out {
+                continue;
+            }
+
             // If it can't possibly expand to a string, provide diagnostics here to include other
             // things it could have been.
             match template.kind {
@@ -288,6 +297,10 @@ pub fn parse_asm_args<'a>(
             p.unexpected_any()?
         };
 
+        if is_configured_out {
+            continue;
+        }
+
         allow_templates = false;
         let span = span_start.to(p.prev_token.span);
         let slot = args.operands.len();
@@ -451,6 +464,7 @@ fn parse_options<'a>(
     p: &mut Parser<'a>,
     args: &mut AsmArgs,
     asm_macro: AsmMacro,
+    is_configured_out: bool,
 ) -> PResult<'a, ()> {
     let span_start = p.prev_token.span;
 
@@ -478,7 +492,9 @@ fn parse_options<'a>(
                 };
 
                 if kw_matched {
-                    try_set_option(p, args, asm_macro, exp.kw, option);
+                    if !is_configured_out {
+                        try_set_option(p, args, asm_macro, exp.kw, option);
+                    }
                     break 'blk;
                 }
             }
@@ -493,8 +509,10 @@ fn parse_options<'a>(
         p.expect(exp!(Comma))?;
     }
 
-    let new_span = span_start.to(p.prev_token.span);
-    args.options_spans.push(new_span);
+    if !is_configured_out {
+        let new_span = span_start.to(p.prev_token.span);
+        args.options_spans.push(new_span);
+    }
 
     Ok(())
 }

tests/ui/asm/cfg.rs

@@ -0,0 +1,103 @@
+// Check that `cfg` and `cfg_attr` work as expected.
+//
+//@ revisions: reva revb
+//@ only-x86_64
+//@ run-pass
+#![feature(asm_cfg, cfg_match)]
+
+use std::arch::{asm, naked_asm};
+
+#[unsafe(naked)]
+extern "C" fn ignore_const_operand() -> u64 {
+    naked_asm!(
+        "mov rax, 5",
+        #[cfg(revb)]
+        "mov rax, {a}",
+        "ret",
+        #[cfg(revb)]
+        a = const 10,
+    )
+}
+
+#[unsafe(naked)]
+extern "C" fn ignore_const_operand_cfg_attr() -> u64 {
+    naked_asm!(
+        "mov rax, 5",
+        #[cfg_attr(true, cfg(revb))]
+        "mov rax, {a}",
+        "ret",
+        #[cfg_attr(true, cfg(revb))]
+        a = const 10,
+    )
+}
+
+#[unsafe(naked)]
+extern "C" fn const_operand() -> u64 {
+    naked_asm!(
+        "mov rax, {a}",
+        "ret",
+        #[cfg(reva)]
+        a = const 5,
+        #[cfg(revb)]
+        a = const 10,
+    )
+}
+
+fn options() {
+    // Without the cfg, this throws an error that the `noreturn` option is provided twice.
+    unsafe {
+        asm!(
+            "nop",
+            #[cfg(false)]
+            options(att_syntax),
+            options(att_syntax)
+        )
+    }
+}
+
+fn clobber_abi() {
+    // Without the cfg, this throws an error that the "C" abi is provided twice.
+    unsafe {
+        asm!(
+            "nop",
+            #[cfg(false)]
+            clobber_abi("C"),
+            clobber_abi("C"),
+        );
+    }
+}
+
+fn template_allowed() {
+    // Without the cfg, templates are not allowed after operands.
+    unsafe {
+        asm!(
+            "nop",
+            #[cfg(false)]
+            clobber_abi("C"),
+            #[cfg(false)]
+            options(att_syntax),
+            #[cfg(false)]
+            a = out(reg) x,
+            "nop",
+        );
+    }
+}
+
+pub fn main() {
+    std::cfg_match! {
+        reva => {
+            assert_eq!(const_operand(), 5);
+            assert_eq!(ignore_const_operand_cfg_attr(), 5);
+            assert_eq!(ignore_const_operand(), 5);
+
+        }
+        revb => {
+            assert_eq!(const_operand(), 10);
+            assert_eq!(ignore_const_operand_cfg_attr(), 10);
+            assert_eq!(ignore_const_operand(), 10);
+        }
+    }
+    options();
+    clobber_abi();
+    template_allowed();
+}