Rollup merge of #93219 - cr1901:msp430-asm-squashed, r=Amanieu

matthiaskrgr · web-flow · commit 552b564df09f · 2022-01-23T20:13:04.000+01:00
Add preliminary support for inline assembly for msp430.

The `llvm_asm` macro was removed recently, and the MSP430 backend relies on inline assembly to build useful embedded apps. I conveniently "found" time to implement basic support for the new inline `asm` macro syntax with the help of `@Amanieu` :D.

In addition to tests in the compiler, I have tested this locally against deployed MSP430 code and have not found any noticeable differences in firmware operation or `objdump` disassemblies between the old `llvm_asm` and the new `asm` syntax.
diff --git a/compiler/rustc_codegen_gcc/src/asm.rs b/compiler/rustc_codegen_gcc/src/asm.rs
@@ -560,6 +560,7 @@ fn reg_to_gcc(reg: InlineAsmRegOrRegClass) -> ConstraintOrRegister {
             InlineAsmRegClass::Hexagon(HexagonInlineAsmRegClass::reg) => unimplemented!(),
             InlineAsmRegClass::Mips(MipsInlineAsmRegClass::reg) => unimplemented!(),
             InlineAsmRegClass::Mips(MipsInlineAsmRegClass::freg) => unimplemented!(),
+            InlineAsmRegClass::Msp430(_) => unimplemented!(),
             InlineAsmRegClass::Nvptx(NvptxInlineAsmRegClass::reg16) => unimplemented!(),
             InlineAsmRegClass::Nvptx(NvptxInlineAsmRegClass::reg32) => unimplemented!(),
             InlineAsmRegClass::Nvptx(NvptxInlineAsmRegClass::reg64) => unimplemented!(),
@@ -622,6 +623,7 @@ fn dummy_output_type<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, reg: InlineAsmRegCl
         InlineAsmRegClass::Hexagon(HexagonInlineAsmRegClass::reg) => cx.type_i32(),
         InlineAsmRegClass::Mips(MipsInlineAsmRegClass::reg) => cx.type_i32(),
         InlineAsmRegClass::Mips(MipsInlineAsmRegClass::freg) => cx.type_f32(),
+        InlineAsmRegClass::Msp430(_) => unimplemented!(),
         InlineAsmRegClass::Nvptx(NvptxInlineAsmRegClass::reg16) => cx.type_i16(),
         InlineAsmRegClass::Nvptx(NvptxInlineAsmRegClass::reg32) => cx.type_i32(),
         InlineAsmRegClass::Nvptx(NvptxInlineAsmRegClass::reg64) => cx.type_i64(),
@@ -729,6 +731,7 @@ fn modifier_to_gcc(arch: InlineAsmArch, reg: InlineAsmRegClass, modifier: Option
         InlineAsmRegClass::Bpf(_) => unimplemented!(),
         InlineAsmRegClass::Hexagon(_) => unimplemented!(),
         InlineAsmRegClass::Mips(_) => unimplemented!(),
+        InlineAsmRegClass::Msp430(_) => unimplemented!(),
         InlineAsmRegClass::Nvptx(_) => unimplemented!(),
         InlineAsmRegClass::PowerPC(_) => unimplemented!(),
         InlineAsmRegClass::RiscV(RiscVInlineAsmRegClass::reg)
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -232,6 +232,9 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 InlineAsmArch::SpirV => {}
                 InlineAsmArch::Wasm32 | InlineAsmArch::Wasm64 => {}
                 InlineAsmArch::Bpf => {}
+                InlineAsmArch::Msp430 => {
+                    constraints.push("~{sr}".to_string());
+                }
             }
         }
         if !options.contains(InlineAsmOptions::NOMEM) {
@@ -580,6 +583,7 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass, layout: Option<&TyAndLayout<'_>>) ->
             InlineAsmRegClass::Avr(AvrInlineAsmRegClass::reg_ptr) => "e",
             InlineAsmRegClass::S390x(S390xInlineAsmRegClass::reg) => "r",
             InlineAsmRegClass::S390x(S390xInlineAsmRegClass::freg) => "f",
+            InlineAsmRegClass::Msp430(Msp430InlineAsmRegClass::reg) => "r",
             InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
                 bug!("LLVM backend does not support SPIR-V")
             }
@@ -666,6 +670,7 @@ fn modifier_to_llvm(
         },
         InlineAsmRegClass::Avr(_) => None,
         InlineAsmRegClass::S390x(_) => None,
+        InlineAsmRegClass::Msp430(_) => None,
         InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
             bug!("LLVM backend does not support SPIR-V")
         }
@@ -734,6 +739,7 @@ fn dummy_output_type<'ll>(cx: &CodegenCx<'ll, '_>, reg: InlineAsmRegClass) -> &'
         InlineAsmRegClass::Avr(AvrInlineAsmRegClass::reg_ptr) => cx.type_i16(),
         InlineAsmRegClass::S390x(S390xInlineAsmRegClass::reg) => cx.type_i32(),
         InlineAsmRegClass::S390x(S390xInlineAsmRegClass::freg) => cx.type_f64(),
+        InlineAsmRegClass::Msp430(Msp430InlineAsmRegClass::reg) => cx.type_i16(),
         InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
             bug!("LLVM backend does not support SPIR-V")
         }
diff --git a/compiler/rustc_target/src/asm/mod.rs b/compiler/rustc_target/src/asm/mod.rs
@@ -152,6 +152,7 @@ mod avr;
 mod bpf;
 mod hexagon;
 mod mips;
+mod msp430;
 mod nvptx;
 mod powerpc;
 mod riscv;
@@ -166,6 +167,7 @@ pub use avr::{AvrInlineAsmReg, AvrInlineAsmRegClass};
 pub use bpf::{BpfInlineAsmReg, BpfInlineAsmRegClass};
 pub use hexagon::{HexagonInlineAsmReg, HexagonInlineAsmRegClass};
 pub use mips::{MipsInlineAsmReg, MipsInlineAsmRegClass};
+pub use msp430::{Msp430InlineAsmReg, Msp430InlineAsmRegClass};
 pub use nvptx::{NvptxInlineAsmReg, NvptxInlineAsmRegClass};
 pub use powerpc::{PowerPCInlineAsmReg, PowerPCInlineAsmRegClass};
 pub use riscv::{RiscVInlineAsmReg, RiscVInlineAsmRegClass};
@@ -194,6 +196,7 @@ pub enum InlineAsmArch {
     Wasm64,
     Bpf,
     Avr,
+    Msp430,
 }
 
 impl FromStr for InlineAsmArch {
@@ -219,6 +222,7 @@ impl FromStr for InlineAsmArch {
             "wasm64" => Ok(Self::Wasm64),
             "bpf" => Ok(Self::Bpf),
             "avr" => Ok(Self::Avr),
+            "msp430" => Ok(Self::Msp430),
             _ => Err(()),
         }
     }
@@ -250,6 +254,7 @@ pub enum InlineAsmReg {
     Wasm(WasmInlineAsmReg),
     Bpf(BpfInlineAsmReg),
     Avr(AvrInlineAsmReg),
+    Msp430(Msp430InlineAsmReg),
     // Placeholder for invalid register constraints for the current target
     Err,
 }
@@ -267,6 +272,7 @@ impl InlineAsmReg {
             Self::S390x(r) => r.name(),
             Self::Bpf(r) => r.name(),
             Self::Avr(r) => r.name(),
+            Self::Msp430(r) => r.name(),
             Self::Err => "<reg>",
         }
     }
@@ -283,6 +289,7 @@ impl InlineAsmReg {
             Self::S390x(r) => InlineAsmRegClass::S390x(r.reg_class()),
             Self::Bpf(r) => InlineAsmRegClass::Bpf(r.reg_class()),
             Self::Avr(r) => InlineAsmRegClass::Avr(r.reg_class()),
+            Self::Msp430(r) => InlineAsmRegClass::Msp430(r.reg_class()),
             Self::Err => InlineAsmRegClass::Err,
         }
     }
@@ -336,6 +343,9 @@ impl InlineAsmReg {
             InlineAsmArch::Avr => {
                 Self::Avr(AvrInlineAsmReg::parse(arch, target_features, target, name)?)
             }
+            InlineAsmArch::Msp430 => {
+                Self::Msp430(Msp430InlineAsmReg::parse(arch, target_features, target, name)?)
+            }
         })
     }
 
@@ -358,6 +368,7 @@ impl InlineAsmReg {
             Self::S390x(r) => r.emit(out, arch, modifier),
             Self::Bpf(r) => r.emit(out, arch, modifier),
             Self::Avr(r) => r.emit(out, arch, modifier),
+            Self::Msp430(r) => r.emit(out, arch, modifier),
             Self::Err => unreachable!("Use of InlineAsmReg::Err"),
         }
     }
@@ -374,6 +385,7 @@ impl InlineAsmReg {
             Self::S390x(_) => cb(self),
             Self::Bpf(r) => r.overlapping_regs(|r| cb(Self::Bpf(r))),
             Self::Avr(r) => r.overlapping_regs(|r| cb(Self::Avr(r))),
+            Self::Msp430(_) => cb(self),
             Self::Err => unreachable!("Use of InlineAsmReg::Err"),
         }
     }
@@ -405,6 +417,7 @@ pub enum InlineAsmRegClass {
     Wasm(WasmInlineAsmRegClass),
     Bpf(BpfInlineAsmRegClass),
     Avr(AvrInlineAsmRegClass),
+    Msp430(Msp430InlineAsmRegClass),
     // Placeholder for invalid register constraints for the current target
     Err,
 }
@@ -425,6 +438,7 @@ impl InlineAsmRegClass {
             Self::Wasm(r) => r.name(),
             Self::Bpf(r) => r.name(),
             Self::Avr(r) => r.name(),
+            Self::Msp430(r) => r.name(),
             Self::Err => rustc_span::symbol::sym::reg,
         }
     }
@@ -447,6 +461,7 @@ impl InlineAsmRegClass {
             Self::Wasm(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Wasm),
             Self::Bpf(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Bpf),
             Self::Avr(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Avr),
+            Self::Msp430(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Msp430),
             Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),
         }
     }
@@ -476,6 +491,7 @@ impl InlineAsmRegClass {
             Self::Wasm(r) => r.suggest_modifier(arch, ty),
             Self::Bpf(r) => r.suggest_modifier(arch, ty),
             Self::Avr(r) => r.suggest_modifier(arch, ty),
+            Self::Msp430(r) => r.suggest_modifier(arch, ty),
             Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),
         }
     }
@@ -501,6 +517,7 @@ impl InlineAsmRegClass {
             Self::Wasm(r) => r.default_modifier(arch),
             Self::Bpf(r) => r.default_modifier(arch),
             Self::Avr(r) => r.default_modifier(arch),
+            Self::Msp430(r) => r.default_modifier(arch),
             Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),
         }
     }
@@ -525,6 +542,7 @@ impl InlineAsmRegClass {
             Self::Wasm(r) => r.supported_types(arch),
             Self::Bpf(r) => r.supported_types(arch),
             Self::Avr(r) => r.supported_types(arch),
+            Self::Msp430(r) => r.supported_types(arch),
             Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),
         }
     }
@@ -554,6 +572,7 @@ impl InlineAsmRegClass {
             }
             InlineAsmArch::Bpf => Self::Bpf(BpfInlineAsmRegClass::parse(arch, name)?),
             InlineAsmArch::Avr => Self::Avr(AvrInlineAsmRegClass::parse(arch, name)?),
+            InlineAsmArch::Msp430 => Self::Msp430(Msp430InlineAsmRegClass::parse(arch, name)?),
         })
     }
 
@@ -574,6 +593,7 @@ impl InlineAsmRegClass {
             Self::Wasm(r) => r.valid_modifiers(arch),
             Self::Bpf(r) => r.valid_modifiers(arch),
             Self::Avr(r) => r.valid_modifiers(arch),
+            Self::Msp430(r) => r.valid_modifiers(arch),
             Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),
         }
     }
@@ -764,6 +784,11 @@ pub fn allocatable_registers(
             avr::fill_reg_map(arch, target_features, target, &mut map);
             map
         }
+        InlineAsmArch::Msp430 => {
+            let mut map = msp430::regclass_map();
+            msp430::fill_reg_map(arch, target_features, target, &mut map);
+            map
+        }
     }
 }
 
diff --git a/compiler/rustc_target/src/asm/msp430.rs b/compiler/rustc_target/src/asm/msp430.rs
@@ -0,0 +1,81 @@
+use super::{InlineAsmArch, InlineAsmType};
+use rustc_macros::HashStable_Generic;
+use rustc_span::Symbol;
+use std::fmt;
+
+def_reg_class! {
+    Msp430 Msp430InlineAsmRegClass {
+        reg,
+    }
+}
+
+impl Msp430InlineAsmRegClass {
+    pub fn valid_modifiers(self, _arch: super::InlineAsmArch) -> &'static [char] {
+        &[]
+    }
+
+    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)> {
+        None
+    }
+
+    pub fn default_modifier(self, _arch: InlineAsmArch) -> Option<(char, &'static str)> {
+        None
+    }
+
+    pub fn supported_types(
+        self,
+        arch: InlineAsmArch,
+    ) -> &'static [(InlineAsmType, Option<Symbol>)] {
+        match (self, arch) {
+            (Self::reg, _) => types! { _: I8, I16; },
+        }
+    }
+}
+
+// The reserved registers are taken from:
+// https://github.com/llvm/llvm-project/blob/36cb29cbbe1b22dcd298ad65e1fabe899b7d7249/llvm/lib/Target/MSP430/MSP430RegisterInfo.cpp#L73.
+def_regs! {
+    Msp430 Msp430InlineAsmReg Msp430InlineAsmRegClass {
+        r5: reg = ["r5"],
+        r6: reg = ["r6"],
+        r7: reg = ["r7"],
+        r8: reg = ["r8"],
+        r9: reg = ["r9"],
+        r10: reg = ["r10"],
+        r11: reg = ["r11"],
+        r12: reg = ["r12"],
+        r13: reg = ["r13"],
+        r14: reg = ["r14"],
+        r15: reg = ["r15"],
+
+        #error = ["r0", "pc"] =>
+            "the program counter cannot be used as an operand for inline asm",
+        #error = ["r1", "sp"] =>
+            "the stack pointer cannot be used as an operand for inline asm",
+        #error = ["r2", "sr"] =>
+            "the status register cannot be used as an operand for inline asm",
+        #error = ["r3", "cg"] =>
+            "the constant generator cannot be used as an operand for inline asm",
+        #error = ["r4", "fp"] =>
+            "the frame pointer cannot be used as an operand for inline asm",
+    }
+}
+
+impl Msp430InlineAsmReg {
+    pub fn emit(
+        self,
+        out: &mut dyn fmt::Write,
+        _arch: InlineAsmArch,
+        _modifier: Option<char>,
+    ) -> fmt::Result {
+        out.write_str(self.name())
+    }
+}
diff --git a/src/doc/unstable-book/src/language-features/asm-experimental-arch.md b/src/doc/unstable-book/src/language-features/asm-experimental-arch.md
@@ -15,6 +15,7 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 - BPF
 - SPIR-V
 - AVR
+- MSP430
 
 ## Register classes
 
@@ -39,6 +40,7 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 | AVR          | `reg_pair`     | `r3r2` .. `r25r24`, `X`, `Z`       | `r`                  |
 | AVR          | `reg_iw`       | `r25r24`, `X`, `Z`                 | `w`                  |
 | AVR          | `reg_ptr`      | `X`, `Z`                           | `e`                  |
+| MSP430       | `reg`          | `r[0-15]`                          | `r`                  |
 
 > **Notes**:
 > - NVPTX doesn't have a fixed register set, so named registers are not supported.
@@ -67,6 +69,7 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 | BPF          | `wreg`                          | `alu32`        | `i8` `i16` `i32`                        |
 | AVR          | `reg`, `reg_upper`              | None           | `i8`                                    |
 | AVR          | `reg_pair`, `reg_iw`, `reg_ptr` | None           | `i16`                                   |
+| MSP430       | `reg`                           | None           | `i8`, `i16`                             |
 
 ## Register aliases
 
@@ -80,13 +83,22 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 | AVR          | `XL`          | `r26`     |
 | AVR          | `ZH`          | `r31`     |
 | AVR          | `ZL`          | `r30`     |
+| MSP430       | `r0`          | `pc`      |
+| MSP430       | `r1`          | `sp`      |
+| MSP430       | `r2`          | `sr`      |
+| MSP430       | `r3`          | `cg`      |
+| MSP430       | `r4`          | `fp`      |
+
+> **Notes**:
+> - TI does not mandate a frame pointer for MSP430, but toolchains are allowed
+    to use one; LLVM uses `r4`.
 
 ## Unsupported registers
 
 | Architecture | Unsupported register                    | Reason                                                                                                                                                                              |
 | ------------ | --------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | All          | `sp`                                    | The stack pointer must be restored to its original value at the end of an asm code block.                                                                                           |
-| All          | `fr` (Hexagon), `$fp` (MIPS), `Y` (AVR) | The frame pointer cannot be used as an input or output.                                                                                                                             |
+| All          | `fr` (Hexagon), `$fp` (MIPS), `Y` (AVR), `r4` (MSP430) | The frame pointer cannot be used as an input or output.                                                                                                                             |
 | All          | `r19` (Hexagon)                         | This is used internally by LLVM as a "base pointer" for functions with complex stack frames.                                                                                        |
 | MIPS         | `$0` or `$zero`                         | This is a constant zero register which can't be modified.                                                                                                                           |
 | MIPS         | `$1` or `$at`                           | Reserved for assembler.                                                                                                                                                             |
@@ -95,6 +107,7 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 | MIPS         | `$ra`                                   | Return address cannot be used as inputs or outputs.                                                                                                                                 |
 | Hexagon      | `lr`                                    | This is the link register which cannot be used as an input or output.                                                                                                               |
 | AVR          | `r0`, `r1`, `r1r0`                      | Due to an issue in LLVM, the `r0` and `r1` registers cannot be used as inputs or outputs.  If modified, they must be restored to their original values before the end of the block. |
+|MSP430        | `r0`, `r2`, `r3`                        | These are the program counter, status register, and constant generator respectively. Neither the status register nor constant generator can be written to.                          |
 
 ## Template modifiers
 
@@ -115,3 +128,5 @@ This feature tracks `asm!` and `global_asm!` support for the following architect
 These flags registers must be restored upon exiting the asm block if the `preserves_flags` option is set:
 - AVR
   - The status register `SREG`.
+- MSP430
+  - The status register `r2`.
diff --git a/src/test/assembly/asm/msp430-types.rs b/src/test/assembly/asm/msp430-types.rs

Original file line number	Diff line number	Diff line change
`@@ -152,6 +152,7 @@ mod avr;`
`152`	`152`	`mod bpf;`
`153`	`153`	`mod hexagon;`
`154`	`154`	`mod mips;`
	`155`	`+mod msp430;`
`155`	`156`	`mod nvptx;`
`156`	`157`	`mod powerpc;`
`157`	`158`	`mod riscv;`
`@@ -166,6 +167,7 @@ pub use avr::{AvrInlineAsmReg, AvrInlineAsmRegClass};`
`166`	`167`	`pub use bpf::{BpfInlineAsmReg, BpfInlineAsmRegClass};`
`167`	`168`	`pub use hexagon::{HexagonInlineAsmReg, HexagonInlineAsmRegClass};`
`168`	`169`	`pub use mips::{MipsInlineAsmReg, MipsInlineAsmRegClass};`
	`170`	`+pub use msp430::{Msp430InlineAsmReg, Msp430InlineAsmRegClass};`
`169`	`171`	`pub use nvptx::{NvptxInlineAsmReg, NvptxInlineAsmRegClass};`
`170`	`172`	`pub use powerpc::{PowerPCInlineAsmReg, PowerPCInlineAsmRegClass};`
`171`	`173`	`pub use riscv::{RiscVInlineAsmReg, RiscVInlineAsmRegClass};`
`@@ -194,6 +196,7 @@ pub enum InlineAsmArch {`
`194`	`196`	`Wasm64,`
`195`	`197`	`Bpf,`
`196`	`198`	`Avr,`
	`199`	`+ Msp430,`
`197`	`200`	`}`
`198`	`201`
`199`	`202`	`impl FromStr for InlineAsmArch {`
`@@ -219,6 +222,7 @@ impl FromStr for InlineAsmArch {`
`219`	`222`	`"wasm64" => Ok(Self::Wasm64),`
`220`	`223`	`"bpf" => Ok(Self::Bpf),`
`221`	`224`	`"avr" => Ok(Self::Avr),`
	`225`	`+ "msp430" => Ok(Self::Msp430),`
`222`	`226`	`_ => Err(()),`
`223`	`227`	`}`
`224`	`228`	`}`
`@@ -250,6 +254,7 @@ pub enum InlineAsmReg {`
`250`	`254`	`Wasm(WasmInlineAsmReg),`
`251`	`255`	`Bpf(BpfInlineAsmReg),`
`252`	`256`	`Avr(AvrInlineAsmReg),`
	`257`	`+ Msp430(Msp430InlineAsmReg),`
`253`	`258`	`// Placeholder for invalid register constraints for the current target`
`254`	`259`	`Err,`
`255`	`260`	`}`
`@@ -267,6 +272,7 @@ impl InlineAsmReg {`
`267`	`272`	`Self::S390x(r) => r.name(),`
`268`	`273`	`Self::Bpf(r) => r.name(),`
`269`	`274`	`Self::Avr(r) => r.name(),`
	`275`	`+ Self::Msp430(r) => r.name(),`
`270`	`276`	`Self::Err => "<reg>",`
`271`	`277`	`}`
`272`	`278`	`}`
`@@ -283,6 +289,7 @@ impl InlineAsmReg {`
`283`	`289`	`Self::S390x(r) => InlineAsmRegClass::S390x(r.reg_class()),`
`284`	`290`	`Self::Bpf(r) => InlineAsmRegClass::Bpf(r.reg_class()),`
`285`	`291`	`Self::Avr(r) => InlineAsmRegClass::Avr(r.reg_class()),`
	`292`	`+ Self::Msp430(r) => InlineAsmRegClass::Msp430(r.reg_class()),`
`286`	`293`	`Self::Err => InlineAsmRegClass::Err,`
`287`	`294`	`}`
`288`	`295`	`}`
`@@ -336,6 +343,9 @@ impl InlineAsmReg {`
`336`	`343`	`InlineAsmArch::Avr => {`
`337`	`344`	`Self::Avr(AvrInlineAsmReg::parse(arch, target_features, target, name)?)`
`338`	`345`	`}`
	`346`	`+ InlineAsmArch::Msp430 => {`
	`347`	`+ Self::Msp430(Msp430InlineAsmReg::parse(arch, target_features, target, name)?)`
	`348`	`+ }`
`339`	`349`	`})`
`340`	`350`	`}`
`341`	`351`
`@@ -358,6 +368,7 @@ impl InlineAsmReg {`
`358`	`368`	`Self::S390x(r) => r.emit(out, arch, modifier),`
`359`	`369`	`Self::Bpf(r) => r.emit(out, arch, modifier),`
`360`	`370`	`Self::Avr(r) => r.emit(out, arch, modifier),`
	`371`	`+ Self::Msp430(r) => r.emit(out, arch, modifier),`
`361`	`372`	`Self::Err => unreachable!("Use of InlineAsmReg::Err"),`
`362`	`373`	`}`
`363`	`374`	`}`
`@@ -374,6 +385,7 @@ impl InlineAsmReg {`
`374`	`385`	`Self::S390x(_) => cb(self),`
`375`	`386`	`Self::Bpf(r) => r.overlapping_regs(\|r\| cb(Self::Bpf(r))),`
`376`	`387`	`Self::Avr(r) => r.overlapping_regs(\|r\| cb(Self::Avr(r))),`
	`388`	`+ Self::Msp430(_) => cb(self),`
`377`	`389`	`Self::Err => unreachable!("Use of InlineAsmReg::Err"),`
`378`	`390`	`}`
`379`	`391`	`}`
`@@ -405,6 +417,7 @@ pub enum InlineAsmRegClass {`
`405`	`417`	`Wasm(WasmInlineAsmRegClass),`
`406`	`418`	`Bpf(BpfInlineAsmRegClass),`
`407`	`419`	`Avr(AvrInlineAsmRegClass),`
	`420`	`+ Msp430(Msp430InlineAsmRegClass),`
`408`	`421`	`// Placeholder for invalid register constraints for the current target`
`409`	`422`	`Err,`
`410`	`423`	`}`
`@@ -425,6 +438,7 @@ impl InlineAsmRegClass {`
`425`	`438`	`Self::Wasm(r) => r.name(),`
`426`	`439`	`Self::Bpf(r) => r.name(),`
`427`	`440`	`Self::Avr(r) => r.name(),`
	`441`	`+ Self::Msp430(r) => r.name(),`
`428`	`442`	`Self::Err => rustc_span::symbol::sym::reg,`
`429`	`443`	`}`
`430`	`444`	`}`
`@@ -447,6 +461,7 @@ impl InlineAsmRegClass {`
`447`	`461`	`Self::Wasm(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Wasm),`
`448`	`462`	`Self::Bpf(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Bpf),`
`449`	`463`	`Self::Avr(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Avr),`
	`464`	`+ Self::Msp430(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Msp430),`
`450`	`465`	`Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),`
`451`	`466`	`}`
`452`	`467`	`}`
`@@ -476,6 +491,7 @@ impl InlineAsmRegClass {`
`476`	`491`	`Self::Wasm(r) => r.suggest_modifier(arch, ty),`
`477`	`492`	`Self::Bpf(r) => r.suggest_modifier(arch, ty),`
`478`	`493`	`Self::Avr(r) => r.suggest_modifier(arch, ty),`
	`494`	`+ Self::Msp430(r) => r.suggest_modifier(arch, ty),`
`479`	`495`	`Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),`
`480`	`496`	`}`
`481`	`497`	`}`
`@@ -501,6 +517,7 @@ impl InlineAsmRegClass {`
`501`	`517`	`Self::Wasm(r) => r.default_modifier(arch),`
`502`	`518`	`Self::Bpf(r) => r.default_modifier(arch),`
`503`	`519`	`Self::Avr(r) => r.default_modifier(arch),`
	`520`	`+ Self::Msp430(r) => r.default_modifier(arch),`
`504`	`521`	`Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),`
`505`	`522`	`}`
`506`	`523`	`}`
`@@ -525,6 +542,7 @@ impl InlineAsmRegClass {`
`525`	`542`	`Self::Wasm(r) => r.supported_types(arch),`
`526`	`543`	`Self::Bpf(r) => r.supported_types(arch),`
`527`	`544`	`Self::Avr(r) => r.supported_types(arch),`
	`545`	`+ Self::Msp430(r) => r.supported_types(arch),`
`528`	`546`	`Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),`
`529`	`547`	`}`
`530`	`548`	`}`
`@@ -554,6 +572,7 @@ impl InlineAsmRegClass {`
`554`	`572`	`}`
`555`	`573`	`InlineAsmArch::Bpf => Self::Bpf(BpfInlineAsmRegClass::parse(arch, name)?),`
`556`	`574`	`InlineAsmArch::Avr => Self::Avr(AvrInlineAsmRegClass::parse(arch, name)?),`
	`575`	`+ InlineAsmArch::Msp430 => Self::Msp430(Msp430InlineAsmRegClass::parse(arch, name)?),`
`557`	`576`	`})`
`558`	`577`	`}`
`559`	`578`
`@@ -574,6 +593,7 @@ impl InlineAsmRegClass {`
`574`	`593`	`Self::Wasm(r) => r.valid_modifiers(arch),`
`575`	`594`	`Self::Bpf(r) => r.valid_modifiers(arch),`
`576`	`595`	`Self::Avr(r) => r.valid_modifiers(arch),`
	`596`	`+ Self::Msp430(r) => r.valid_modifiers(arch),`
`577`	`597`	`Self::Err => unreachable!("Use of InlineAsmRegClass::Err"),`
`578`	`598`	`}`
`579`	`599`	`}`
`@@ -764,6 +784,11 @@ pub fn allocatable_registers(`
`764`	`784`	`avr::fill_reg_map(arch, target_features, target, &mut map);`
`765`	`785`	`map`
`766`	`786`	`}`
	`787`	`+ InlineAsmArch::Msp430 => {`
	`788`	`+ let mut map = msp430::regclass_map();`
	`789`	`+ msp430::fill_reg_map(arch, target_features, target, &mut map);`
	`790`	`+ map`
	`791`	`+ }`
`767`	`792`	`}`
`768`	`793`	`}`
`769`	`794`