Allow rustdoc to handle asm! of foreign architectures

Amanieu · Amanieu · commit f927f150d4b9 · 2021-03-06T16:17:35.000Z
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -1242,14 +1242,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_expr_asm(&mut self, sp: Span, asm: &InlineAsm) -> hir::ExprKind<'hir> {
-        if self.sess.asm_arch.is_none() {
+        if self.sess.asm_arch.is_none() && !self.sess.opts.actually_rustdoc {
             struct_span_err!(self.sess, sp, E0472, "asm! is unsupported on this target").emit();
         }
         if asm.options.contains(InlineAsmOptions::ATT_SYNTAX)
             && !matches!(
                 self.sess.asm_arch,
                 Some(asm::InlineAsmArch::X86 | asm::InlineAsmArch::X86_64)
             )
+            && !self.sess.opts.actually_rustdoc
         {
             self.sess
                 .struct_span_err(sp, "the `att_syntax` option is only supported on x86")
@@ -1265,6 +1266,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
             .filter_map(|(op, op_sp)| {
                 let lower_reg = |reg| {
                     Some(match reg {
+                        InlineAsmRegOrRegClass::Reg(_) if sess.opts.actually_rustdoc => {
+                            asm::InlineAsmRegOrRegClass::Reg(asm::InlineAsmReg::RustdocDummy)
+                        }
+                        InlineAsmRegOrRegClass::RegClass(_) if sess.opts.actually_rustdoc => {
+                            asm::InlineAsmRegOrRegClass::RegClass(
+                                asm::InlineAsmRegClass::RustdocDummy,
+                            )
+                        }
                         InlineAsmRegOrRegClass::Reg(s) => asm::InlineAsmRegOrRegClass::Reg(
                             asm::InlineAsmReg::parse(
                                 sess.asm_arch?,
@@ -1355,7 +1364,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     | hir::InlineAsmOperand::SplitInOut { reg, .. } => {
                         let class = reg.reg_class();
                         let valid_modifiers = class.valid_modifiers(asm_arch);
-                        if !valid_modifiers.contains(&modifier) {
+                        if !valid_modifiers.contains(&modifier) && !self.sess.opts.actually_rustdoc
+                        {
                             let mut err = sess.struct_span_err(
                                 placeholder_span,
                                 "invalid asm template modifier for this register class",
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -524,6 +524,7 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass, layout: Option<&TyAndLayout<'tcx>>)
             InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
                 bug!("LLVM backend does not support SPIR-V")
             }
+            InlineAsmRegClass::RustdocDummy => unreachable!(),
         }
         .to_string(),
     }
@@ -590,6 +591,7 @@ fn modifier_to_llvm(
         InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
             bug!("LLVM backend does not support SPIR-V")
         }
+        InlineAsmRegClass::RustdocDummy => unreachable!(),
     }
 }
 
@@ -633,6 +635,7 @@ fn dummy_output_type(cx: &CodegenCx<'ll, 'tcx>, reg: InlineAsmRegClass) -> &'ll
         InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
             bug!("LLVM backend does not support SPIR-V")
         }
+        InlineAsmRegClass::RustdocDummy => unreachable!(),
     }
 }
 
diff --git a/compiler/rustc_target/src/asm/mod.rs b/compiler/rustc_target/src/asm/mod.rs
@@ -218,6 +218,8 @@ pub enum InlineAsmReg {
     Mips(MipsInlineAsmReg),
     SpirV(SpirVInlineAsmReg),
     Wasm(WasmInlineAsmReg),
+    // Fake register used by rustdoc to support foreign asm!
+    RustdocDummy,
 }
 
 impl InlineAsmReg {
@@ -229,6 +231,7 @@ impl InlineAsmReg {
             Self::RiscV(r) => r.name(),
             Self::Hexagon(r) => r.name(),
             Self::Mips(r) => r.name(),
+            Self::RustdocDummy => "<reg>",
         }
     }
 
@@ -240,6 +243,7 @@ impl InlineAsmReg {
             Self::RiscV(r) => InlineAsmRegClass::RiscV(r.reg_class()),
             Self::Hexagon(r) => InlineAsmRegClass::Hexagon(r.reg_class()),
             Self::Mips(r) => InlineAsmRegClass::Mips(r.reg_class()),
+            Self::RustdocDummy => InlineAsmRegClass::RustdocDummy,
         }
     }
 
@@ -298,6 +302,7 @@ impl InlineAsmReg {
             Self::RiscV(r) => r.emit(out, arch, modifier),
             Self::Hexagon(r) => r.emit(out, arch, modifier),
             Self::Mips(r) => r.emit(out, arch, modifier),
+            Self::RustdocDummy => unreachable!(),
         }
     }
 
@@ -309,6 +314,10 @@ impl InlineAsmReg {
             Self::RiscV(_) => cb(self),
             Self::Hexagon(r) => r.overlapping_regs(|r| cb(Self::Hexagon(r))),
             Self::Mips(_) => cb(self),
+            Self::RustdocDummy => {
+                // This effectively disables the register conflict check since
+                // we don't report RustdocDummy as conflicting with itself.
+            }
         }
     }
 }
@@ -324,6 +333,8 @@ pub enum InlineAsmRegClass {
     Mips(MipsInlineAsmRegClass),
     SpirV(SpirVInlineAsmRegClass),
     Wasm(WasmInlineAsmRegClass),
+    // Fake register class used by rustdoc to support foreign asm!
+    RustdocDummy,
 }
 
 impl InlineAsmRegClass {
@@ -338,6 +349,7 @@ impl InlineAsmRegClass {
             Self::Mips(r) => r.name(),
             Self::SpirV(r) => r.name(),
             Self::Wasm(r) => r.name(),
+            Self::RustdocDummy => rustc_span::symbol::sym::reg,
         }
     }
 
@@ -355,6 +367,7 @@ impl InlineAsmRegClass {
             Self::Mips(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Mips),
             Self::SpirV(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::SpirV),
             Self::Wasm(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Wasm),
+            Self::RustdocDummy => None,
         }
     }
 
@@ -379,6 +392,7 @@ impl InlineAsmRegClass {
             Self::Mips(r) => r.suggest_modifier(arch, ty),
             Self::SpirV(r) => r.suggest_modifier(arch, ty),
             Self::Wasm(r) => r.suggest_modifier(arch, ty),
+            Self::RustdocDummy => None,
         }
     }
 
@@ -399,6 +413,7 @@ impl InlineAsmRegClass {
             Self::Mips(r) => r.default_modifier(arch),
             Self::SpirV(r) => r.default_modifier(arch),
             Self::Wasm(r) => r.default_modifier(arch),
+            Self::RustdocDummy => None,
         }
     }
 
@@ -418,6 +433,9 @@ impl InlineAsmRegClass {
             Self::Mips(r) => r.supported_types(arch),
             Self::SpirV(r) => r.supported_types(arch),
             Self::Wasm(r) => r.supported_types(arch),
+            // Rustdoc never gets around to type-checking the asm!, this is just
+            // used to indicate the lack of any dependency on target features.
+            Self::RustdocDummy => &[],
         }
     }
 
@@ -454,6 +472,8 @@ impl InlineAsmRegClass {
             Self::Mips(r) => r.valid_modifiers(arch),
             Self::SpirV(r) => r.valid_modifiers(arch),
             Self::Wasm(r) => r.valid_modifiers(arch),
+            // The modifier check is skipped in the code for rustdoc
+            Self::RustdocDummy => &[],
         }
     }
 }
diff --git a/src/test/rustdoc-ui/asm-foreign.rs b/src/test/rustdoc-ui/asm-foreign.rs
@@ -0,0 +1,16 @@
+// check-pass
+// Make sure rustdoc accepts asm! for a foreign architecture.
+
+#![feature(asm)]
+
+pub unsafe fn aarch64(a: f64, b: f64) {
+    let c;
+    asm!("add {:d}, {:d}, d0", out(vreg) c, in(vreg) a, in("d0") b);
+    c
+}
+
+pub unsafe fn x86(a: f64, b: f64) {
+    let c;
+    asm!("addsd {}, {}, xmm0", out(xmm_reg) c, in(xmm_reg) a, in("xmm0") b);
+    c
+}

Original file line number	Diff line number	Diff line change
`@@ -524,6 +524,7 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass, layout: Option<&TyAndLayout<'tcx>>)`
`524`	`524`	`InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {`
`525`	`525`	`bug!("LLVM backend does not support SPIR-V")`
`526`	`526`	`}`
	`527`	`+ InlineAsmRegClass::RustdocDummy => unreachable!(),`
`527`	`528`	`}`
`528`	`529`	`.to_string(),`
`529`	`530`	`}`
`@@ -590,6 +591,7 @@ fn modifier_to_llvm(`
`590`	`591`	`InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {`
`591`	`592`	`bug!("LLVM backend does not support SPIR-V")`
`592`	`593`	`}`
	`594`	`+ InlineAsmRegClass::RustdocDummy => unreachable!(),`
`593`	`595`	`}`
`594`	`596`	`}`
`595`	`597`
`@@ -633,6 +635,7 @@ fn dummy_output_type(cx: &CodegenCx<'ll, 'tcx>, reg: InlineAsmRegClass) -> &'ll`
`633`	`635`	`InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {`
`634`	`636`	`bug!("LLVM backend does not support SPIR-V")`
`635`	`637`	`}`
	`638`	`+ InlineAsmRegClass::RustdocDummy => unreachable!(),`
`636`	`639`	`}`
`637`	`640`	`}`
`638`	`641`
Original file line number	Diff line number	Diff line change
`@@ -218,6 +218,8 @@ pub enum InlineAsmReg {`
`218`	`218`	`Mips(MipsInlineAsmReg),`
`219`	`219`	`SpirV(SpirVInlineAsmReg),`
`220`	`220`	`Wasm(WasmInlineAsmReg),`
	`221`	`+ // Fake register used by rustdoc to support foreign asm!`
	`222`	`+ RustdocDummy,`
`221`	`223`	`}`
`222`	`224`
`223`	`225`	`impl InlineAsmReg {`
`@@ -229,6 +231,7 @@ impl InlineAsmReg {`
`229`	`231`	`Self::RiscV(r) => r.name(),`
`230`	`232`	`Self::Hexagon(r) => r.name(),`
`231`	`233`	`Self::Mips(r) => r.name(),`
	`234`	`+ Self::RustdocDummy => "<reg>",`
`232`	`235`	`}`
`233`	`236`	`}`
`234`	`237`
`@@ -240,6 +243,7 @@ impl InlineAsmReg {`
`240`	`243`	`Self::RiscV(r) => InlineAsmRegClass::RiscV(r.reg_class()),`
`241`	`244`	`Self::Hexagon(r) => InlineAsmRegClass::Hexagon(r.reg_class()),`
`242`	`245`	`Self::Mips(r) => InlineAsmRegClass::Mips(r.reg_class()),`
	`246`	`+ Self::RustdocDummy => InlineAsmRegClass::RustdocDummy,`
`243`	`247`	`}`
`244`	`248`	`}`
`245`	`249`
`@@ -298,6 +302,7 @@ impl InlineAsmReg {`
`298`	`302`	`Self::RiscV(r) => r.emit(out, arch, modifier),`
`299`	`303`	`Self::Hexagon(r) => r.emit(out, arch, modifier),`
`300`	`304`	`Self::Mips(r) => r.emit(out, arch, modifier),`
	`305`	`+ Self::RustdocDummy => unreachable!(),`
`301`	`306`	`}`
`302`	`307`	`}`
`303`	`308`
`@@ -309,6 +314,10 @@ impl InlineAsmReg {`
`309`	`314`	`Self::RiscV(_) => cb(self),`
`310`	`315`	`Self::Hexagon(r) => r.overlapping_regs(\|r\| cb(Self::Hexagon(r))),`
`311`	`316`	`Self::Mips(_) => cb(self),`
	`317`	`+ Self::RustdocDummy => {`
	`318`	`+ // This effectively disables the register conflict check since`
	`319`	`+ // we don't report RustdocDummy as conflicting with itself.`
	`320`	`+ }`
`312`	`321`	`}`
`313`	`322`	`}`
`314`	`323`	`}`
`@@ -324,6 +333,8 @@ pub enum InlineAsmRegClass {`
`324`	`333`	`Mips(MipsInlineAsmRegClass),`
`325`	`334`	`SpirV(SpirVInlineAsmRegClass),`
`326`	`335`	`Wasm(WasmInlineAsmRegClass),`
	`336`	`+ // Fake register class used by rustdoc to support foreign asm!`
	`337`	`+ RustdocDummy,`
`327`	`338`	`}`
`328`	`339`
`329`	`340`	`impl InlineAsmRegClass {`
`@@ -338,6 +349,7 @@ impl InlineAsmRegClass {`
`338`	`349`	`Self::Mips(r) => r.name(),`
`339`	`350`	`Self::SpirV(r) => r.name(),`
`340`	`351`	`Self::Wasm(r) => r.name(),`
	`352`	`+ Self::RustdocDummy => rustc_span::symbol::sym::reg,`
`341`	`353`	`}`
`342`	`354`	`}`
`343`	`355`
`@@ -355,6 +367,7 @@ impl InlineAsmRegClass {`
`355`	`367`	`Self::Mips(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Mips),`
`356`	`368`	`Self::SpirV(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::SpirV),`
`357`	`369`	`Self::Wasm(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Wasm),`
	`370`	`+ Self::RustdocDummy => None,`
`358`	`371`	`}`
`359`	`372`	`}`
`360`	`373`
`@@ -379,6 +392,7 @@ impl InlineAsmRegClass {`
`379`	`392`	`Self::Mips(r) => r.suggest_modifier(arch, ty),`
`380`	`393`	`Self::SpirV(r) => r.suggest_modifier(arch, ty),`
`381`	`394`	`Self::Wasm(r) => r.suggest_modifier(arch, ty),`
	`395`	`+ Self::RustdocDummy => None,`
`382`	`396`	`}`
`383`	`397`	`}`
`384`	`398`
`@@ -399,6 +413,7 @@ impl InlineAsmRegClass {`
`399`	`413`	`Self::Mips(r) => r.default_modifier(arch),`
`400`	`414`	`Self::SpirV(r) => r.default_modifier(arch),`
`401`	`415`	`Self::Wasm(r) => r.default_modifier(arch),`
	`416`	`+ Self::RustdocDummy => None,`
`402`	`417`	`}`
`403`	`418`	`}`
`404`	`419`
`@@ -418,6 +433,9 @@ impl InlineAsmRegClass {`
`418`	`433`	`Self::Mips(r) => r.supported_types(arch),`
`419`	`434`	`Self::SpirV(r) => r.supported_types(arch),`
`420`	`435`	`Self::Wasm(r) => r.supported_types(arch),`
	`436`	`+ // Rustdoc never gets around to type-checking the asm!, this is just`
	`437`	`+ // used to indicate the lack of any dependency on target features.`
	`438`	`+ Self::RustdocDummy => &[],`
`421`	`439`	`}`
`422`	`440`	`}`
`423`	`441`
`@@ -454,6 +472,8 @@ impl InlineAsmRegClass {`
`454`	`472`	`Self::Mips(r) => r.valid_modifiers(arch),`
`455`	`473`	`Self::SpirV(r) => r.valid_modifiers(arch),`
`456`	`474`	`Self::Wasm(r) => r.valid_modifiers(arch),`
	`475`	`+ // The modifier check is skipped in the code for rustdoc`
	`476`	`+ Self::RustdocDummy => &[],`
`457`	`477`	`}`
`458`	`478`	`}`
`459`	`479`	`}`