compiler/rustc_target/src/asm/powerpc.rs

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