mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Feat: added inline asm support for s390x

Browse source
This commit is contained in:
linux1 2021-08-06 17:53:29 -04:00
parent 91f9806208
commit f28793dd13
3 changed files with 187 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
compiler/rustc_codegen_llvm/src/asm.rs
View file

@ -314,6 +314,7 @@ impl AsmBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
InlineAsmArch::PowerPC | InlineAsmArch::PowerPC64 => {}
InlineAsmArch::Hexagon => {}
InlineAsmArch::Mips | InlineAsmArch::Mips64 => {}
InlineAsmArch::s390 => {}
InlineAsmArch::SpirV => {}
InlineAsmArch::Wasm32 => {}
InlineAsmArch::Bpf => {}
@ -633,6 +634,8 @@ fn reg_to_llvm(reg: InlineAsmRegOrRegClass, layout: Option<&TyAndLayout<'tcx>>)
InlineAsmRegClass::Wasm(WasmInlineAsmRegClass::local) => "r",
InlineAsmRegClass::Bpf(BpfInlineAsmRegClass::reg) => "r",
InlineAsmRegClass::Bpf(BpfInlineAsmRegClass::wreg) => "w",
InlineAsmRegClass::s390x(s390xInlineAsmRegClass::reg) => "r",
InlineAsmRegClass::s390x(s390xInlineAsmRegClass::freg) => "f",
InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
bug!("LLVM backend does not support SPIR-V")
}
@ -711,6 +714,7 @@ fn modifier_to_llvm(
}
InlineAsmRegClass::Wasm(WasmInlineAsmRegClass::local) => None,
InlineAsmRegClass::Bpf(_) => None,
InlineAsmRegClass::s390x(_) => None,
InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
bug!("LLVM backend does not support SPIR-V")
}
@ -769,6 +773,8 @@ fn dummy_output_type(cx: &CodegenCx<'ll, 'tcx>, reg: InlineAsmRegClass) -> &'ll
InlineAsmRegClass::Wasm(WasmInlineAsmRegClass::local) => cx.type_i32(),
InlineAsmRegClass::Bpf(BpfInlineAsmRegClass::reg) => cx.type_i64(),
InlineAsmRegClass::Bpf(BpfInlineAsmRegClass::wreg) => cx.type_i32(),
InlineAsmRegClass::s390x(s390xInlineAsmRegClass::reg) => cx.type_i32(),
InlineAsmRegClass::s390x(s390xInlineAsmRegClass::freg) => cx.type_f64(),
InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
bug!("LLVM backend does not support SPIR-V")
}

25
compiler/rustc_target/src/asm/mod.rs
View file

@ -154,6 +154,7 @@ mod mips;
mod nvptx;
mod powerpc;
mod riscv;
mod s390x;
mod spirv;
mod wasm;
mod x86;
@ -166,6 +167,7 @@ pub use mips::{MipsInlineAsmReg, MipsInlineAsmRegClass};
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};
@ -184,6 +186,7 @@ pub enum InlineAsmArch {
Mips64,
PowerPC,
PowerPC64,
s390x,
SpirV,
Wasm32,
Bpf,
@ -206,6 +209,7 @@ impl FromStr for InlineAsmArch {
"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),
@ -235,6 +239,7 @@ pub enum InlineAsmReg {
PowerPC(PowerPCInlineAsmReg),
Hexagon(HexagonInlineAsmReg),
Mips(MipsInlineAsmReg),
s390x(InlineAsmReg),
SpirV(SpirVInlineAsmReg),
Wasm(WasmInlineAsmReg),
Bpf(BpfInlineAsmReg),
@ -252,6 +257,7 @@ impl InlineAsmReg {
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>",
}
@ -266,6 +272,7 @@ impl InlineAsmReg {
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,
}
@ -305,6 +312,9 @@ impl InlineAsmReg {
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)?)
}
@ -333,6 +343,7 @@ impl InlineAsmReg {
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"),
}
@ -347,6 +358,7 @@ impl InlineAsmReg {
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"),
}
@ -374,6 +386,7 @@ pub enum InlineAsmRegClass {
PowerPC(PowerPCInlineAsmRegClass),
Hexagon(HexagonInlineAsmRegClass),
Mips(MipsInlineAsmRegClass),
s390x(s390xInlineAsmRegClass),
SpirV(SpirVInlineAsmRegClass),
Wasm(WasmInlineAsmRegClass),
Bpf(BpfInlineAsmRegClass),
@ -392,6 +405,7 @@ impl InlineAsmRegClass {
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(),
@ -412,6 +426,7 @@ impl InlineAsmRegClass {
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),
@ -439,6 +454,7 @@ impl InlineAsmRegClass {
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),
@ -462,6 +478,7 @@ impl InlineAsmRegClass {
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),
@ -484,6 +501,7 @@ impl InlineAsmRegClass {
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),
@ -509,6 +527,7 @@ impl InlineAsmRegClass {
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)?),
@ -527,6 +546,7 @@ impl InlineAsmRegClass {
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),
@ -695,6 +715,11 @@ pub fn allocatable_registers(
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);

156
compiler/rustc_target/src/asm/s390x.rs Normal file
View file

@ -0,0 +1,156 @@
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())
}
}