mod nvptx;
mod powerpc;
mod riscv;
+mod s390x;
mod spirv;
mod wasm;
mod x86;
pub use nvptx::{NvptxInlineAsmReg, NvptxInlineAsmRegClass};
pub use powerpc::{PowerPCInlineAsmReg, PowerPCInlineAsmRegClass};
pub use riscv::{RiscVInlineAsmReg, RiscVInlineAsmRegClass};
+pub use s390x::{s390xInlineAsmReg, s390xInlineAsmRegClass};
pub use spirv::{SpirVInlineAsmReg, SpirVInlineAsmRegClass};
pub use wasm::{WasmInlineAsmReg, WasmInlineAsmRegClass};
pub use x86::{X86InlineAsmReg, X86InlineAsmRegClass};
Mips64,
PowerPC,
PowerPC64,
+ s390x,
SpirV,
Wasm32,
Bpf,
"hexagon" => Ok(Self::Hexagon),
"mips" => Ok(Self::Mips),
"mips64" => Ok(Self::Mips64),
+ "s390x" => Ok(Self::s390x),
"spirv" => Ok(Self::SpirV),
"wasm32" => Ok(Self::Wasm32),
"bpf" => Ok(Self::Bpf),
PowerPC(PowerPCInlineAsmReg),
Hexagon(HexagonInlineAsmReg),
Mips(MipsInlineAsmReg),
+ s390x(InlineAsmReg),
SpirV(SpirVInlineAsmReg),
Wasm(WasmInlineAsmReg),
Bpf(BpfInlineAsmReg),
Self::PowerPC(r) => r.name(),
Self::Hexagon(r) => r.name(),
Self::Mips(r) => r.name(),
+ Self::s390x(r) => r.name(),
Self::Bpf(r) => r.name(),
Self::Err => "<reg>",
}
Self::PowerPC(r) => InlineAsmRegClass::PowerPC(r.reg_class()),
Self::Hexagon(r) => InlineAsmRegClass::Hexagon(r.reg_class()),
Self::Mips(r) => InlineAsmRegClass::Mips(r.reg_class()),
+ Self::s390x(r) => InlineAsmRegClass::s390x(r.reg_class()),
Self::Bpf(r) => InlineAsmRegClass::Bpf(r.reg_class()),
Self::Err => InlineAsmRegClass::Err,
}
InlineAsmArch::Mips | InlineAsmArch::Mips64 => {
Self::Mips(MipsInlineAsmReg::parse(arch, has_feature, target, &name)?)
}
+ InlineAsmArch::s390x => {
+ Self::s390x(s390xInlineAsmReg::parse(arch, has_feature, target, &name)?)
+ }
InlineAsmArch::SpirV => {
Self::SpirV(SpirVInlineAsmReg::parse(arch, has_feature, target, &name)?)
}
Self::PowerPC(r) => r.emit(out, arch, modifier),
Self::Hexagon(r) => r.emit(out, arch, modifier),
Self::Mips(r) => r.emit(out, arch, modifier),
+ Self::s390x(r) => r.emit(out, arch, modifier),
Self::Bpf(r) => r.emit(out, arch, modifier),
Self::Err => unreachable!("Use of InlineAsmReg::Err"),
}
Self::PowerPC(_) => cb(self),
Self::Hexagon(r) => r.overlapping_regs(|r| cb(Self::Hexagon(r))),
Self::Mips(_) => cb(self),
+ Self::s390x(_) => cb(self),
Self::Bpf(r) => r.overlapping_regs(|r| cb(Self::Bpf(r))),
Self::Err => unreachable!("Use of InlineAsmReg::Err"),
}
PowerPC(PowerPCInlineAsmRegClass),
Hexagon(HexagonInlineAsmRegClass),
Mips(MipsInlineAsmRegClass),
+ s390x(s390xInlineAsmRegClass),
SpirV(SpirVInlineAsmRegClass),
Wasm(WasmInlineAsmRegClass),
Bpf(BpfInlineAsmRegClass),
Self::PowerPC(r) => r.name(),
Self::Hexagon(r) => r.name(),
Self::Mips(r) => r.name(),
+ Self::s390x(r) => r.name(),
Self::SpirV(r) => r.name(),
Self::Wasm(r) => r.name(),
Self::Bpf(r) => r.name(),
Self::PowerPC(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::PowerPC),
Self::Hexagon(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Hexagon),
Self::Mips(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Mips),
+ Self::s390x(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::s390x),
Self::SpirV(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::SpirV),
Self::Wasm(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Wasm),
Self::Bpf(r) => r.suggest_class(arch, ty).map(InlineAsmRegClass::Bpf),
Self::PowerPC(r) => r.suggest_modifier(arch, ty),
Self::Hexagon(r) => r.suggest_modifier(arch, ty),
Self::Mips(r) => r.suggest_modifier(arch, ty),
+ Self::s390x(r) => r.suggest_modifier(arch, ty),
Self::SpirV(r) => r.suggest_modifier(arch, ty),
Self::Wasm(r) => r.suggest_modifier(arch, ty),
Self::Bpf(r) => r.suggest_modifier(arch, ty),
Self::PowerPC(r) => r.default_modifier(arch),
Self::Hexagon(r) => r.default_modifier(arch),
Self::Mips(r) => r.default_modifier(arch),
+ Self::s390x(r) => r.default_modifier(arch),
Self::SpirV(r) => r.default_modifier(arch),
Self::Wasm(r) => r.default_modifier(arch),
Self::Bpf(r) => r.default_modifier(arch),
Self::PowerPC(r) => r.supported_types(arch),
Self::Hexagon(r) => r.supported_types(arch),
Self::Mips(r) => r.supported_types(arch),
+ Self::s390x(r) => r.supported_types(arch),
Self::SpirV(r) => r.supported_types(arch),
Self::Wasm(r) => r.supported_types(arch),
Self::Bpf(r) => r.supported_types(arch),
InlineAsmArch::Mips | InlineAsmArch::Mips64 => {
Self::Mips(MipsInlineAsmRegClass::parse(arch, name)?)
}
+ InlineAsmArch::s390x => Self::s390x(s390xInlineAsmRegClass::parse(arch, name)?),
InlineAsmArch::SpirV => Self::SpirV(SpirVInlineAsmRegClass::parse(arch, name)?),
InlineAsmArch::Wasm32 => Self::Wasm(WasmInlineAsmRegClass::parse(arch, name)?),
InlineAsmArch::Bpf => Self::Bpf(BpfInlineAsmRegClass::parse(arch, name)?),
Self::PowerPC(r) => r.valid_modifiers(arch),
Self::Hexagon(r) => r.valid_modifiers(arch),
Self::Mips(r) => r.valid_modifiers(arch),
+ Self::s390x(r) => r.valid_modifiers(arch),
Self::SpirV(r) => r.valid_modifiers(arch),
Self::Wasm(r) => r.valid_modifiers(arch),
Self::Bpf(r) => r.valid_modifiers(arch),
mips::fill_reg_map(arch, has_feature, target, &mut map);
map
}
+ InlineAsmArch::s390x => {
+ let mut map = s390x::regclass_map();
+ s390x::fill_reg_map(arch, has_feature, target, &mut map);
+ map
+ }
InlineAsmArch::SpirV => {
let mut map = spirv::regclass_map();
spirv::fill_reg_map(arch, has_feature, target, &mut map);
--- /dev/null
+use super::{InlineAsmArch, InlineAsmType};
+use rustc_macros::HashStable_Generic;
+use std::fmt;
+
+def_reg_class! {
+ s390x s390xInlineAsmRegClass {
+ reg,
+ freg,
+ }
+}
+
+impl s390xInlineAsmRegClass {
+ 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<&'static str>)] {
+ match (self, arch) {
+ (Self::reg, _) => types! { _: I8, I16, I32; },
+ (Self::freg, _) => types! { _: F32, F64; },
+ }
+ }
+}
+
+def_regs! {
+ s390x s390xInlineAsmReg s390xInlineAsmRegClass {
+ r0: req = ["r0"],
+ r1: reg = ["r1"],
+ r2: reg = ["r2"],
+ r3: reg = ["r3"],
+ r4: reg = ["r4"],
+ r5: reg = ["r5"],
+ r6: reg = ["r6"],
+ r7: reg = ["r7"],
+ r8: reg = ["r8"],
+ r9: reg = ["r9"],
+ r10: reg = ["r10"],
+ r11: reg = ["r11"],
+ r12: reg = ["r12"],
+ r14: reg = ["r14"],
+ f0: freg = ["f0"],
+ f1: freg = ["f1"],
+ f2: freg = ["f2"],
+ f3: freg = ["f3"],
+ f4: freg = ["f4"],
+ f5: freg = ["f5"],
+ f6: freg = ["f6"],
+ f7: freg = ["f7"],
+ f8: freg = ["f8"],
+ f9: freg = ["f9"],
+ f10: freg = ["f10"],
+ f11: freg = ["f11"],
+ f12: freg = ["f12"],
+ f13: freg = ["f13"],
+ f14: freg = ["f14"],
+ f15: freg = ["f15"],
+ #error = ["r13"] =>
+ "The base pointer cannot be used as an operand for inline asm",
+ #error = ["r15"] =>
+ "The stack pointer cannot be used as an operand for inline asm",
+ #error = ["a0"] =>
+ "This pointer is reserved on s390x and cannot be used as an operand for inline asm",
+ #error = ["a1"] =>
+ "This pointer is reserved on z/Arch and cannot be used as an operand for inline asm",
+ #error = ["c0"] =>
+ "c0 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c1"] =>
+ "c1 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c2"] =>
+ "c2 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c3"] =>
+ "c3 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c4"] =>
+ "c4 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c5"] =>
+ "c5 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c6"] =>
+ "c6 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c7"] =>
+ "c7 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c8"] =>
+ "c8 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c9"] =>
+ "c9 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c10"] =>
+ "c10 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c11"] =>
+ "c11 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c12"] =>
+ "c12 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c13"] =>
+ "c13 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c14"] =>
+ "c14 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["c15"] =>
+ "c15 is reserved by the kernel and cannot be used as an operand for inline asm",
+ #error = ["a2"] =>
+ "a2 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a3"] =>
+ "a3 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a4"] =>
+ "a4 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a5"] =>
+ "a5 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a6"] =>
+ "a6 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a7"] =>
+ "a7 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a8"] =>
+ "a8 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a9"] =>
+ "a9 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a10"] =>
+ "a10 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a11"] =>
+ "a11 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a12"] =>
+ "a12 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a13"] =>
+ "a13 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a14"] =>
+ "a14 is not supported by LLVM and cannot be used as an operand for inline asm",
+ #error = ["a15"] =>
+ "a15 is not supported by LLVM and cannot be used as an operand for inline asm",
+ }
+}
+
+impl s390xInlineAsmReg {
+ pub fn emit(
+ self,
+ out: &mut dyn fmt::Write,
+ _arch: InlineAsmArch,
+ _modifier: Option<char>,
+ ) -> fmt::Result {
+ out.write_str(self.name())
+ }
+}