compiler/rustc_target/src/asm/avr.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     Avr AvrInlineAsmRegClass {
   8         reg,
   9         reg_upper,
  10         reg_pair,
  11         reg_iw,
  12         reg_ptr,
  13     }
  14 }
  15
  16 impl AvrInlineAsmRegClass {
  17     pub fn valid_modifiers(self, _arch: InlineAsmArch) -> &'static [char] {
  18         match self {
  19             Self::reg_pair | Self::reg_iw | Self::reg_ptr => &['h', 'l'],
  20             _ => &[],
  21         }
  22     }
  23
  24     pub fn suggest_class(self, _arch: InlineAsmArch, _ty: InlineAsmType) -> Option<Self> {
  25         None
  26     }
  27
  28     pub fn suggest_modifier(
  29         self,
  30         _arch: InlineAsmArch,
  31         _ty: InlineAsmType,
  32     ) -> Option<(char, &'static str)> {
  33         None
  34     }
  35
  36     pub fn default_modifier(self, _arch: InlineAsmArch) -> Option<(char, &'static str)> {
  37         None
  38     }
  39
  40     pub fn supported_types(
  41         self,
  42         _arch: InlineAsmArch,
  43     ) -> &'static [(InlineAsmType, Option<Symbol>)] {
  44         match self {
  45             Self::reg => types! { _: I8; },
  46             Self::reg_upper => types! { _: I8; },
  47             Self::reg_pair => types! { _: I16; },
  48             Self::reg_iw => types! { _: I16; },
  49             Self::reg_ptr => types! { _: I16; },
  50         }
  51     }
  52 }
  53
  54 def_regs! {
  55     Avr AvrInlineAsmReg AvrInlineAsmRegClass {
  56         r2: reg = ["r2"],
  57         r3: reg = ["r3"],
  58         r4: reg = ["r4"],
  59         r5: reg = ["r5"],
  60         r6: reg = ["r6"],
  61         r7: reg = ["r7"],
  62         r8: reg = ["r8"],
  63         r9: reg = ["r9"],
  64         r10: reg = ["r10"],
  65         r11: reg = ["r11"],
  66         r12: reg = ["r12"],
  67         r13: reg = ["r13"],
  68         r14: reg = ["r14"],
  69         r15: reg = ["r15"],
  70         r16: reg, reg_upper = ["r16"],
  71         r17: reg, reg_upper = ["r17"],
  72         r18: reg, reg_upper = ["r18"],
  73         r19: reg, reg_upper = ["r19"],
  74         r20: reg, reg_upper = ["r20"],
  75         r21: reg, reg_upper = ["r21"],
  76         r22: reg, reg_upper = ["r22"],
  77         r23: reg, reg_upper = ["r23"],
  78         r24: reg, reg_upper = ["r24"],
  79         r25: reg, reg_upper = ["r25"],
  80         r26: reg, reg_upper = ["r26", "XL"],
  81         r27: reg, reg_upper = ["r27", "XH"],
  82         r30: reg, reg_upper = ["r30", "ZL"],
  83         r31: reg, reg_upper = ["r31", "ZH"],
  84
  85         r3r2: reg_pair = ["r3r2"],
  86         r5r4: reg_pair = ["r5r4"],
  87         r7r6: reg_pair = ["r7r6"],
  88         r9r8: reg_pair = ["r9r8"],
  89         r11r10: reg_pair = ["r11r10"],
  90         r13r12: reg_pair = ["r13r12"],
  91         r15r14: reg_pair = ["r15r14"],
  92         r17r16: reg_pair = ["r17r16"],
  93         r19r18: reg_pair = ["r19r18"],
  94         r21r20: reg_pair = ["r21r20"],
  95         r23r22: reg_pair = ["r23r22"],
  96
  97         r25r24: reg_iw, reg_pair = ["r25r24"],
  98
  99         X: reg_ptr, reg_iw, reg_pair = ["r27r26", "X"],
 100         Z: reg_ptr, reg_iw, reg_pair = ["r31r30", "Z"],
 101
 102         #error = ["Y", "YL", "YH"] =>
 103             "the frame pointer cannot be used as an operand for inline asm",
 104         #error = ["SP", "SPL", "SPH"] =>
 105             "the stack pointer cannot be used as an operand for inline asm",
 106         #error = ["r0", "r1", "r1r0"] =>
 107             "r0 and r1 are not available due to an issue in LLVM",
 108     }
 109 }
 110
 111 macro_rules! emit_pairs {
 112     (
 113         $self:ident $modifier:ident,
 114         $($pair:ident $name:literal $hi:literal $lo:literal,)*
 115     ) => {
 116         match ($self, $modifier) {
 117             $(
 118                 (AvrInlineAsmReg::$pair, Some('h')) => $hi,
 119                 (AvrInlineAsmReg::$pair, Some('l')) => $lo,
 120                 (AvrInlineAsmReg::$pair, _) => $name,
 121             )*
 122             _ => $self.name(),
 123         }
 124     };
 125 }
 126
 127 impl AvrInlineAsmReg {
 128     pub fn emit(
 129         self,
 130         out: &mut dyn fmt::Write,
 131         _arch: InlineAsmArch,
 132         modifier: Option<char>,
 133     ) -> fmt::Result {
 134         let name = emit_pairs! {
 135             self modifier,
 136             Z "Z" "ZH" "ZL",
 137             X "X" "XH" "XL",
 138             r25r24 "r25:r24" "r25" "r24",
 139             r23r22 "r23:r22" "r23" "r22",
 140             r21r20 "r21:r20" "r21" "r20",
 141             r19r18 "r19:r18" "r19" "r18",
 142             r17r16 "r17:r16" "r17" "r16",
 143             r15r14 "r15:r14" "r15" "r14",
 144             r13r12 "r13:r12" "r13" "r12",
 145             r11r10 "r11:r10" "r11" "r10",
 146             r9r8 "r9:r8" "r9" "r8",
 147             r7r6 "r7:r6" "r7" "r6",
 148             r5r4 "r5:r4" "r5" "r4",
 149             r3r2 "r3:r2" "r3" "r2",
 150         };
 151         out.write_str(name)
 152     }
 153
 154     pub fn overlapping_regs(self, mut cb: impl FnMut(AvrInlineAsmReg)) {
 155         cb(self);
 156
 157         macro_rules! reg_conflicts {
 158             (
 159                 $(
 160                     $pair:ident : $hi:ident $lo:ident,
 161                 )*
 162             ) => {
 163                 match self {
 164                     $(
 165                         Self::$pair => {
 166                             cb(Self::$hi);
 167                             cb(Self::$lo);
 168                         }
 169                         Self::$hi => {
 170                             cb(Self::$pair);
 171                         }
 172                         Self::$lo => {
 173                             cb(Self::$pair);
 174                         }
 175                     )*
 176                 }
 177             };
 178         }
 179
 180         reg_conflicts! {
 181             Z : r31 r30,
 182             X : r27 r26,
 183             r25r24 : r25 r24,
 184             r23r22 : r23 r22,
 185             r21r20 : r21 r20,
 186             r19r18 : r19 r18,
 187             r17r16 : r17 r16,
 188             r15r14 : r15 r14,
 189             r13r12 : r13 r12,
 190             r11r10 : r11 r10,
 191             r9r8 : r9 r8,
 192             r7r6 : r7 r6,
 193             r5r4 : r5 r4,
 194             r3r2 : r3 r2,
 195         }
 196     }
 197 }