Add support for high byte registers on x86

Author: Amanieu

src/librustc_codegen_llvm/asm.rs

@@ -409,6 +409,7 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass) -> String {
             InlineAsmRegClass::RiscV(RiscVInlineAsmRegClass::freg) => "f",
             InlineAsmRegClass::X86(X86InlineAsmRegClass::reg) => "r",
             InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd) => "Q",
+            InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_byte) => "r",
             InlineAsmRegClass::X86(X86InlineAsmRegClass::xmm_reg)
             | InlineAsmRegClass::X86(X86InlineAsmRegClass::ymm_reg) => "x",
             InlineAsmRegClass::X86(X86InlineAsmRegClass::zmm_reg) => "v",
@@ -459,6 +460,7 @@ fn modifier_to_llvm(
             Some('r') => Some('q'),
             _ => unreachable!(),
         },
+        InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_byte) => None,
         InlineAsmRegClass::X86(reg @ X86InlineAsmRegClass::xmm_reg)
         | InlineAsmRegClass::X86(reg @ X86InlineAsmRegClass::ymm_reg)
         | InlineAsmRegClass::X86(reg @ X86InlineAsmRegClass::zmm_reg) => match (reg, modifier) {
@@ -499,6 +501,7 @@ fn dummy_output_type(cx: &CodegenCx<'ll, 'tcx>, reg: InlineAsmRegClass) -> &'ll
         InlineAsmRegClass::RiscV(RiscVInlineAsmRegClass::freg) => cx.type_f32(),
         InlineAsmRegClass::X86(X86InlineAsmRegClass::reg)
         | InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd) => cx.type_i32(),
+        InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_byte) => cx.type_i8(),
         InlineAsmRegClass::X86(X86InlineAsmRegClass::xmm_reg)
         | InlineAsmRegClass::X86(X86InlineAsmRegClass::ymm_reg)
         | InlineAsmRegClass::X86(X86InlineAsmRegClass::zmm_reg) => cx.type_f32(),

src/librustc_passes/intrinsicck.rs

@@ -268,6 +268,12 @@ impl ExprVisitor<'tcx> {
                     reg_class.name(),
                     supported_tys.join(", "),
                 ));
+                if let Some(suggest) = reg_class.suggest_class(asm_arch, asm_ty) {
+                    err.help(&format!(
+                        "consider using the `{}` register class instead",
+                        suggest.name()
+                    ));
+                }
                 err.emit();
                 return Some(asm_ty);
             }
@@ -298,7 +304,7 @@ impl ExprVisitor<'tcx> {
         }
 
         // Check whether a modifier is suggested for using this type.
-        if let Some((suggested_modifier, suggested_result, switch_reg_class)) =
+        if let Some((suggested_modifier, suggested_result)) =
             reg_class.suggest_modifier(asm_arch, asm_ty)
         {
             // Search for any use of this operand without a modifier and emit
@@ -323,18 +329,10 @@ impl ExprVisitor<'tcx> {
                         let msg = "formatting may not be suitable for sub-register argument";
                         let mut err = lint.build(msg);
                         err.span_label(expr.span, "for this argument");
-                        if let Some(switch_reg_class) = switch_reg_class {
-                            err.help(&format!(
-                                "use the `{}` modifier with the `{}` register class \
-                                 to have the register formatted as `{}`",
-                                suggested_modifier, switch_reg_class, suggested_result,
-                            ));
-                        } else {
-                            err.help(&format!(
-                                "use the `{}` modifier to have the register formatted as `{}`",
-                                suggested_modifier, suggested_result,
-                            ));
-                        }
+                        err.help(&format!(
+                            "use the `{}` modifier to have the register formatted as `{}`",
+                            suggested_modifier, suggested_result,
+                        ));
                         err.help(&format!(
                             "or use the `{}` modifier to keep the default formatting of `{}`",
                             default_modifier, default_result,

src/librustc_target/asm/aarch64.rs

@@ -18,22 +18,26 @@ impl AArch64InlineAsmRegClass {
         }
     }
 
+    pub fn suggest_class(self, _arch: InlineAsmArch, _ty: InlineAsmType) -> Option<Self> {
+        None
+    }
+
     pub fn suggest_modifier(
         self,
         _arch: InlineAsmArch,
         ty: InlineAsmType,
-    ) -> Option<(char, &'static str, Option<&'static str>)> {
+    ) -> Option<(char, &'static str)> {
         match self {
             Self::reg => match ty.size().bits() {
                 64 => None,
-                _ => Some(('w', "w0", None)),
+                _ => Some(('w', "w0")),
             },
             Self::vreg | Self::vreg_low16 => match ty.size().bits() {
-                8 => Some(('b', "b0", None)),
-                16 => Some(('h', "h0", None)),
-                32 => Some(('s', "s0", None)),
-                64 => Some(('d', "d0", None)),
-                128 => Some(('q', "q0", None)),
+                8 => Some(('b', "b0")),
+                16 => Some(('h', "h0")),
+                32 => Some(('s', "s0")),
+                64 => Some(('d', "d0")),
+                128 => Some(('q', "q0")),
                 _ => None,
             },
         }

src/librustc_target/asm/arm.rs

@@ -25,11 +25,15 @@ impl ArmInlineAsmRegClass {
         }
     }
 
+    pub fn suggest_class(self, _arch: InlineAsmArch, _ty: InlineAsmType) -> Option<Self> {
+        None
+    }
+
     pub fn suggest_modifier(
         self,
         _arch: InlineAsmArch,
         _ty: InlineAsmType,
-    ) -> Option<(char, &'static str, Option<&'static str>)> {
+    ) -> Option<(char, &'static str)> {
         None
     }
 

src/librustc_target/asm/mod.rs

@@ -291,9 +291,20 @@ impl InlineAsmRegClass {
         }
     }
 
+    /// Returns a suggested register class to use for this type. This is called
+    /// after type checking via `supported_types` fails to give a better error
+    /// message to the user.
+    pub fn suggest_class(self, arch: InlineAsmArch, ty: InlineAsmType) -> Option<Self> {
+        match self {
+            Self::X86(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::X86),
+            Self::Arm(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Arm),
+            Self::AArch64(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::AArch64),
+            Self::RiscV(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::RiscV),
+        }
+    }
+
     /// Returns a suggested template modifier to use for this type and an
-    /// example of a  register named formatted with it. Optionally also returns
-    /// the name of a different register class to use instead.
+    /// example of a  register named formatted with it.
     ///
     /// Such suggestions are useful if a type smaller than the full register
     /// size is used and a modifier can be used to point to the subregister of
@@ -302,7 +313,7 @@ impl InlineAsmRegClass {
         self,
         arch: InlineAsmArch,
         ty: InlineAsmType,
-    ) -> Option<(char, &'static str, Option<&'static str>)> {
+    ) -> Option<(char, &'static str)> {
         match self {
             Self::X86(r) => r.suggest_modifier(arch, ty),
             Self::Arm(r) => r.suggest_modifier(arch, ty),

src/librustc_target/asm/riscv.rs

@@ -14,11 +14,15 @@ impl RiscVInlineAsmRegClass {
         &[]
     }
 
+    pub fn suggest_class(self, _arch: InlineAsmArch, _ty: InlineAsmType) -> Option<Self> {
+        None
+    }
+
     pub fn suggest_modifier(
         self,
         _arch: InlineAsmArch,
         _ty: InlineAsmType,
-    ) -> Option<(char, &'static str, Option<&'static str>)> {
+    ) -> Option<(char, &'static str)> {
         None
     }