]>
Commit | Line | Data |
---|---|---|
17df50a5 XL |
1 | use super::{InlineAsmArch, InlineAsmType}; |
2 | use rustc_macros::HashStable_Generic; | |
3 | use std::fmt; | |
4 | ||
5 | def_reg_class! { | |
6 | PowerPC PowerPCInlineAsmRegClass { | |
7 | reg, | |
8 | reg_nonzero, | |
9 | freg, | |
10 | } | |
11 | } | |
12 | ||
13 | impl PowerPCInlineAsmRegClass { | |
14 | pub fn valid_modifiers(self, _arch: super::InlineAsmArch) -> &'static [char] { | |
15 | &[] | |
16 | } | |
17 | ||
18 | pub fn suggest_class(self, _arch: InlineAsmArch, _ty: InlineAsmType) -> Option<Self> { | |
19 | None | |
20 | } | |
21 | ||
22 | pub fn suggest_modifier( | |
23 | self, | |
24 | _arch: InlineAsmArch, | |
25 | _ty: InlineAsmType, | |
26 | ) -> Option<(char, &'static str)> { | |
27 | None | |
28 | } | |
29 | ||
30 | pub fn default_modifier(self, _arch: InlineAsmArch) -> Option<(char, &'static str)> { | |
31 | None | |
32 | } | |
33 | ||
34 | pub fn supported_types( | |
35 | self, | |
36 | arch: InlineAsmArch, | |
37 | ) -> &'static [(InlineAsmType, Option<&'static str>)] { | |
38 | match self { | |
39 | Self::reg | Self::reg_nonzero => { | |
40 | if arch == InlineAsmArch::PowerPC { | |
41 | types! { _: I8, I16, I32; } | |
42 | } else { | |
43 | types! { _: I8, I16, I32, I64; } | |
44 | } | |
45 | } | |
46 | Self::freg => types! { _: F32, F64; }, | |
47 | } | |
48 | } | |
49 | } | |
50 | ||
51 | def_regs! { | |
52 | PowerPC PowerPCInlineAsmReg PowerPCInlineAsmRegClass { | |
53 | r0: reg = ["r0", "0"], | |
54 | r3: reg, reg_nonzero = ["r3", "3"], | |
55 | r4: reg, reg_nonzero = ["r4", "4"], | |
56 | r5: reg, reg_nonzero = ["r5", "5"], | |
57 | r6: reg, reg_nonzero = ["r6", "6"], | |
58 | r7: reg, reg_nonzero = ["r7", "7"], | |
59 | r8: reg, reg_nonzero = ["r8", "8"], | |
60 | r9: reg, reg_nonzero = ["r9", "9"], | |
61 | r10: reg, reg_nonzero = ["r10", "10"], | |
62 | r11: reg, reg_nonzero = ["r11", "11"], | |
63 | r12: reg, reg_nonzero = ["r12", "12"], | |
64 | r14: reg, reg_nonzero = ["r14", "14"], | |
65 | r15: reg, reg_nonzero = ["r15", "15"], | |
66 | r16: reg, reg_nonzero = ["r16", "16"], | |
67 | r17: reg, reg_nonzero = ["r17", "17"], | |
68 | r18: reg, reg_nonzero = ["r18", "18"], | |
69 | r19: reg, reg_nonzero = ["r19", "19"], | |
70 | r20: reg, reg_nonzero = ["r20", "20"], | |
71 | r21: reg, reg_nonzero = ["r21", "21"], | |
72 | r22: reg, reg_nonzero = ["r22", "22"], | |
73 | r23: reg, reg_nonzero = ["r23", "23"], | |
74 | r24: reg, reg_nonzero = ["r24", "24"], | |
75 | r25: reg, reg_nonzero = ["r25", "25"], | |
76 | r26: reg, reg_nonzero = ["r26", "26"], | |
77 | r27: reg, reg_nonzero = ["r27", "27"], | |
78 | r28: reg, reg_nonzero = ["r28", "28"], | |
79 | f0: freg = ["f0", "fr0"], | |
80 | f1: freg = ["f1", "fr1"], | |
81 | f2: freg = ["f2", "fr2"], | |
82 | f3: freg = ["f3", "fr3"], | |
83 | f4: freg = ["f4", "fr4"], | |
84 | f5: freg = ["f5", "fr5"], | |
85 | f6: freg = ["f6", "fr6"], | |
86 | f7: freg = ["f7", "fr7"], | |
87 | f8: freg = ["f8", "fr8"], | |
88 | f9: freg = ["f9", "fr9"], | |
89 | f10: freg = ["f10", "fr10"], | |
90 | f11: freg = ["f11", "fr11"], | |
91 | f12: freg = ["f12", "fr12"], | |
92 | f13: freg = ["f13", "fr13"], | |
93 | f14: freg = ["f14", "fr14"], | |
94 | f15: freg = ["f15", "fr15"], | |
95 | f16: freg = ["f16", "fr16"], | |
96 | f17: freg = ["f17", "fr17"], | |
97 | f18: freg = ["f18", "fr18"], | |
98 | f19: freg = ["f19", "fr19"], | |
99 | f20: freg = ["f20", "fr20"], | |
100 | f21: freg = ["f21", "fr21"], | |
101 | f22: freg = ["f22", "fr22"], | |
102 | f23: freg = ["f23", "fr23"], | |
103 | f24: freg = ["f24", "fr24"], | |
104 | f25: freg = ["f25", "fr25"], | |
105 | f26: freg = ["f26", "fr26"], | |
106 | f27: freg = ["f27", "fr27"], | |
107 | f28: freg = ["f28", "fr28"], | |
108 | f29: freg = ["f29", "fr29"], | |
109 | f30: freg = ["f30", "fr30"], | |
110 | f31: freg = ["f31", "fr31"], | |
111 | #error = ["r1", "1", "sp"] => | |
112 | "the stack pointer cannot be used as an operand for inline asm", | |
113 | #error = ["r2", "2"] => | |
114 | "r2 is a system reserved register and cannot be used as an operand for inline asm", | |
115 | #error = ["r13", "13"] => | |
116 | "r13 is a system reserved register and cannot be used as an operand for inline asm", | |
117 | #error = ["r29", "29"] => | |
118 | "r29 is used internally by LLVM and cannot be used as an operand for inline asm", | |
119 | #error = ["r30", "30"] => | |
120 | "r30 is used internally by LLVM and cannot be used as an operand for inline asm", | |
121 | #error = ["r31", "31", "fp"] => | |
122 | "the frame pointer cannot be used as an operand for inline asm", | |
123 | #error = ["lr"] => | |
124 | "the link register cannot be used as an operand for inline asm", | |
125 | #error = ["ctr"] => | |
126 | "the counter register cannot be used as an operand for inline asm", | |
127 | #error = ["vrsave"] => | |
128 | "the vrsave register cannot be used as an operand for inline asm", | |
129 | } | |
130 | } | |
131 | ||
132 | impl PowerPCInlineAsmReg { | |
133 | pub fn emit( | |
134 | self, | |
135 | out: &mut dyn fmt::Write, | |
136 | _arch: InlineAsmArch, | |
137 | _modifier: Option<char>, | |
138 | ) -> fmt::Result { | |
139 | // Strip off the leading prefix. | |
140 | if self as u32 <= Self::r28 as u32 { | |
141 | let index = self as u32 - Self::r28 as u32; | |
142 | write!(out, "{}", index) | |
143 | } else if self as u32 >= Self::f0 as u32 && self as u32 <= Self::f31 as u32 { | |
144 | let index = self as u32 - Self::f31 as u32; | |
145 | write!(out, "{}", index) | |
146 | } else { | |
147 | unreachable!() | |
148 | } | |
149 | } | |
150 | ||
151 | pub fn overlapping_regs(self, mut _cb: impl FnMut(PowerPCInlineAsmReg)) {} | |
152 | } |