src/test/assembly/asm/avr-types.rs

   1 // assembly-output: emit-asm
   2 // compile-flags: --target avr-unknown-gnu-atmega328
   3 // needs-llvm-components: avr
   4
   5 #![feature(no_core, lang_items, rustc_attrs, asm_experimental_arch)]
   6 #![crate_type = "rlib"]
   7 #![no_core]
   8 #![allow(non_camel_case_types)]
   9
  10 #[rustc_builtin_macro]
  11 macro_rules! asm {
  12     () => {};
  13 }
  14 #[rustc_builtin_macro]
  15 macro_rules! concat {
  16     () => {};
  17 }
  18
  19 #[lang = "sized"]
  20 trait Sized {}
  21 #[lang = "copy"]
  22 trait Copy {}
  23
  24 type ptr = *const u64;
  25
  26 impl Copy for i8 {}
  27 impl Copy for i16 {}
  28 impl Copy for i32 {}
  29 impl Copy for i64 {}
  30 impl Copy for ptr {}
  31
  32 macro_rules! check {
  33     ($func:ident $ty:ident $class:ident) => {
  34         #[no_mangle]
  35         pub unsafe fn $func(x: $ty) -> $ty {
  36             let y;
  37             asm!("mov {}, {}", lateout($class) y, in($class) x);
  38             y
  39         }
  40     };
  41 }
  42
  43 macro_rules! checkw {
  44     ($func:ident $ty:ident $class:ident) => {
  45         #[no_mangle]
  46         pub unsafe fn $func(x: $ty) -> $ty {
  47             let y;
  48             asm!("movw {}, {}", lateout($class) y, in($class) x);
  49             y
  50         }
  51     };
  52 }
  53
  54 macro_rules! check_reg {
  55     ($func:ident $ty:ident $reg:tt) => {
  56         #[no_mangle]
  57         pub unsafe fn $func(x: $ty) -> $ty {
  58             let y;
  59             asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
  60             y
  61         }
  62     };
  63 }
  64
  65 macro_rules! check_regw {
  66     ($func:ident $ty:ident $reg:tt $reg_lit:tt) => {
  67         #[no_mangle]
  68         pub unsafe fn $func(x: $ty) -> $ty {
  69             let y;
  70             asm!(concat!("movw ", $reg_lit, ", ", $reg_lit), lateout($reg) y, in($reg) x);
  71             y
  72         }
  73     };
  74 }
  75
  76 extern "C" {
  77     fn extern_func();
  78     static extern_static: i8;
  79 }
  80
  81 // CHECK-LABEL: sym_fn
  82 // CHECK: ;APP
  83 // CHECK: call extern_func
  84 // CHECK: ;NO_APP
  85 #[no_mangle]
  86 pub unsafe fn sym_fn() {
  87     asm!("call {}", sym extern_func);
  88 }
  89
  90 // CHECK-LABEL: sym_static
  91 // CHECK: ;APP
  92 // CHECK: lds r{{[0-9]+}}, extern_static
  93 // CHECK: ;NO_APP
  94 #[no_mangle]
  95 pub unsafe fn sym_static() -> i8 {
  96     let y;
  97     asm!("lds {}, {}", lateout(reg) y, sym extern_static);
  98     y
  99 }
 100
 101 // CHECK-LABEL: ld_z:
 102 // CHECK: ;APP
 103 // CHECK: ld r{{[0-9]+}}, Z
 104 // CHECK: ;NO_APP
 105 #[no_mangle]
 106 pub unsafe fn ld_z(x: i16) -> i8 {
 107     let y;
 108     asm!("ld {}, Z", out(reg) y, in("Z") x);
 109     y
 110 }
 111
 112 // CHECK-LABEL: ldd_z:
 113 // CHECK: ;APP
 114 // CHECK: ldd r{{[0-9]+}}, Z+4
 115 // CHECK: ;NO_APP
 116 #[no_mangle]
 117 pub unsafe fn ldd_z(x: i16) -> i8 {
 118     let y;
 119     asm!("ldd {}, Z+4", out(reg) y, in("Z") x);
 120     y
 121 }
 122
 123 // CHECK-LABEL: ld_predecrement:
 124 // CHECK: ;APP
 125 // CHECK: ld r{{[0-9]+}}, -Z
 126 // CHECK: ;NO_APP
 127 #[no_mangle]
 128 pub unsafe fn ld_predecrement(x: i16) -> i8 {
 129     let y;
 130     asm!("ld {}, -Z", out(reg) y, in("Z") x);
 131     y
 132 }
 133
 134 // CHECK-LABEL: ld_postincrement:
 135 // CHECK: ;APP
 136 // CHECK: ld r{{[0-9]+}}, Z+
 137 // CHECK: ;NO_APP
 138 #[no_mangle]
 139 pub unsafe fn ld_postincrement(x: i16) -> i8 {
 140     let y;
 141     asm!("ld {}, Z+", out(reg) y, in("Z") x);
 142     y
 143 }
 144
 145 // CHECK-LABEL: muls_clobber:
 146 // CHECK: ;APP
 147 // CHECK: muls r{{[0-9]+}}, r{{[0-9]+}}
 148 // CHECK: movw r{{[0-9]+}}, r0
 149 // CHECK: ;NO_APP
 150 #[no_mangle]
 151 pub unsafe fn muls_clobber(x: i8, y: i8) -> i16 {
 152     let z;
 153     asm!(
 154         "muls {}, {}",
 155         "movw {}, r1:r0",
 156         out(reg_iw) z,
 157         in(reg) x,
 158         in(reg) y,
 159     );
 160     z
 161 }
 162
 163 // CHECK-LABEL: reg_i8:
 164 // CHECK: ;APP
 165 // CHECK: mov r{{[0-9]+}}, r{{[0-9]+}}
 166 // CHECK: ;NO_APP
 167 check!(reg_i8 i8 reg);
 168
 169 // CHECK-LABEL: reg_upper_i8:
 170 // CHECK: ;APP
 171 // CHECK: mov r{{[1-3][0-9]}}, r{{[1-3][0-9]}}
 172 // CHECK: ;NO_APP
 173 check!(reg_upper_i8 i8 reg_upper);
 174
 175 // CHECK-LABEL: reg_pair_i16:
 176 // CHECK: ;APP
 177 // CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
 178 // CHECK: ;NO_APP
 179 checkw!(reg_pair_i16 i16 reg_pair);
 180
 181 // CHECK-LABEL: reg_iw_i16:
 182 // CHECK: ;APP
 183 // CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
 184 // CHECK: ;NO_APP
 185 checkw!(reg_iw_i16 i16 reg_iw);
 186
 187 // CHECK-LABEL: reg_ptr_i16:
 188 // CHECK: ;APP
 189 // CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
 190 // CHECK: ;NO_APP
 191 checkw!(reg_ptr_i16 i16 reg_ptr);
 192
 193 // CHECK-LABEL: r2_i8:
 194 // CHECK: ;APP
 195 // CHECK: mov r2, r2
 196 // CHECK: ;NO_APP
 197 check_reg!(r2_i8 i8 "r2");
 198
 199 // CHECK-LABEL: xl_i8:
 200 // CHECK: ;APP
 201 // CHECK: mov r26, r26
 202 // CHECK: ;NO_APP
 203 check_reg!(xl_i8 i8 "XL");
 204
 205 // CHECK-LABEL: xh_i8:
 206 // CHECK: ;APP
 207 // CHECK: mov r27, r27
 208 // CHECK: ;NO_APP
 209 check_reg!(xh_i8 i8 "XH");
 210
 211 // CHECK-LABEL: x_i16:
 212 // CHECK: ;APP
 213 // CHECK: movw r26, r26
 214 // CHECK: ;NO_APP
 215 check_regw!(x_i16 i16 "X" "X");
 216
 217 // CHECK-LABEL: r25r24_i16:
 218 // CHECK: ;APP
 219 // CHECK: movw r24, r24
 220 // CHECK: ;NO_APP
 221 check_regw!(r25r24_i16 i16 "r25r24" "r24");