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

   1 // min-llvm-version: 10.0.1
   2 // revisions: riscv64 riscv32
   3 // assembly-output: emit-asm
   4 //[riscv64] compile-flags: --target riscv64imac-unknown-none-elf
   5 //[riscv32] compile-flags: --target riscv32imac-unknown-none-elf
   6 // compile-flags: -C target-feature=+d
   7 // needs-llvm-components: riscv
   8 // min-system-llvm-version: 12.0
   9
  10 #![feature(no_core, lang_items, rustc_attrs)]
  11 #![crate_type = "rlib"]
  12 #![no_core]
  13 #![allow(asm_sub_register)]
  14
  15 #[rustc_builtin_macro]
  16 macro_rules! asm {
  17     () => {};
  18 }
  19 #[rustc_builtin_macro]
  20 macro_rules! concat {
  21     () => {};
  22 }
  23 #[rustc_builtin_macro]
  24 macro_rules! stringify {
  25     () => {};
  26 }
  27
  28 #[lang = "sized"]
  29 trait Sized {}
  30 #[lang = "copy"]
  31 trait Copy {}
  32
  33 type ptr = *mut u8;
  34
  35 impl Copy for i8 {}
  36 impl Copy for i16 {}
  37 impl Copy for i32 {}
  38 impl Copy for f32 {}
  39 impl Copy for i64 {}
  40 impl Copy for f64 {}
  41 impl Copy for ptr {}
  42
  43 extern "C" {
  44     fn extern_func();
  45     static extern_static: u8;
  46 }
  47
  48 // CHECK-LABEL: sym_fn:
  49 // CHECK: #APP
  50 // CHECK: call extern_func
  51 // CHECK: #NO_APP
  52 #[no_mangle]
  53 pub unsafe fn sym_fn() {
  54     asm!("call {}", sym extern_func);
  55 }
  56
  57 // CHECK-LABEL: sym_static:
  58 // CHECK: #APP
  59 // CHECK: auipc t0, %pcrel_hi(extern_static)
  60 // CHECK: lb t0, %pcrel_lo(.Lpcrel_hi0)(t0)
  61 // CHECK: #NO_APP
  62 #[no_mangle]
  63 pub unsafe fn sym_static() {
  64     asm!("lb t0, {}", sym extern_static);
  65 }
  66
  67 macro_rules! check {
  68     ($func:ident $ty:ident $class:ident $mov:literal) => {
  69         #[no_mangle]
  70         pub unsafe fn $func(x: $ty) -> $ty {
  71             // Hack to avoid function merging
  72             extern "Rust" {
  73                 fn dont_merge(s: &str);
  74             }
  75             dont_merge(stringify!($func));
  76
  77             let y;
  78             asm!(concat!($mov, " {}, {}"), out($class) y, in($class) x);
  79             y
  80         }
  81     };
  82 }
  83
  84 macro_rules! check_reg {
  85     ($func:ident $ty:ident $reg:tt $mov:literal) => {
  86         #[no_mangle]
  87         pub unsafe fn $func(x: $ty) -> $ty {
  88             // Hack to avoid function merging
  89             extern "Rust" {
  90                 fn dont_merge(s: &str);
  91             }
  92             dont_merge(stringify!($func));
  93
  94             let y;
  95             asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
  96             y
  97         }
  98     };
  99 }
 100
 101 // CHECK-LABEL: reg_i8:
 102 // CHECK: #APP
 103 // CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
 104 // CHECK: #NO_APP
 105 check!(reg_i8 i8 reg "mv");
 106
 107 // CHECK-LABEL: reg_i16:
 108 // CHECK: #APP
 109 // CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
 110 // CHECK: #NO_APP
 111 check!(reg_i16 i16 reg "mv");
 112
 113 // CHECK-LABEL: reg_i32:
 114 // CHECK: #APP
 115 // CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
 116 // CHECK: #NO_APP
 117 check!(reg_i32 i32 reg "mv");
 118
 119 // CHECK-LABEL: reg_f32:
 120 // CHECK: #APP
 121 // CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
 122 // CHECK: #NO_APP
 123 check!(reg_f32 f32 reg "mv");
 124
 125 // riscv64-LABEL: reg_i64:
 126 // riscv64: #APP
 127 // riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
 128 // riscv64: #NO_APP
 129 #[cfg(riscv64)]
 130 check!(reg_i64 i64 reg "mv");
 131
 132 // riscv64-LABEL: reg_f64:
 133 // riscv64: #APP
 134 // riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
 135 // riscv64: #NO_APP
 136 #[cfg(riscv64)]
 137 check!(reg_f64 f64 reg "mv");
 138
 139 // CHECK-LABEL: reg_ptr:
 140 // CHECK: #APP
 141 // CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
 142 // CHECK: #NO_APP
 143 check!(reg_ptr ptr reg "mv");
 144
 145 // CHECK-LABEL: freg_f32:
 146 // CHECK: #APP
 147 // CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
 148 // CHECK: #NO_APP
 149 check!(freg_f32 f32 freg "fmv.s");
 150
 151 // CHECK-LABEL: freg_f64:
 152 // CHECK: #APP
 153 // CHECK: fmv.d f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
 154 // CHECK: #NO_APP
 155 check!(freg_f64 f64 freg "fmv.d");
 156
 157 // CHECK-LABEL: a0_i8:
 158 // CHECK: #APP
 159 // CHECK: mv a0, a0
 160 // CHECK: #NO_APP
 161 check_reg!(a0_i8 i8 "a0" "mv");
 162
 163 // CHECK-LABEL: a0_i16:
 164 // CHECK: #APP
 165 // CHECK: mv a0, a0
 166 // CHECK: #NO_APP
 167 check_reg!(a0_i16 i16 "a0" "mv");
 168
 169 // CHECK-LABEL: a0_i32:
 170 // CHECK: #APP
 171 // CHECK: mv a0, a0
 172 // CHECK: #NO_APP
 173 check_reg!(a0_i32 i32 "a0" "mv");
 174
 175 // CHECK-LABEL: a0_f32:
 176 // CHECK: #APP
 177 // CHECK: mv a0, a0
 178 // CHECK: #NO_APP
 179 check_reg!(a0_f32 f32 "a0" "mv");
 180
 181 // riscv64-LABEL: a0_i64:
 182 // riscv64: #APP
 183 // riscv64: mv a0, a0
 184 // riscv64: #NO_APP
 185 #[cfg(riscv64)]
 186 check_reg!(a0_i64 i64 "a0" "mv");
 187
 188 // riscv64-LABEL: a0_f64:
 189 // riscv64: #APP
 190 // riscv64: mv a0, a0
 191 // riscv64: #NO_APP
 192 #[cfg(riscv64)]
 193 check_reg!(a0_f64 f64 "a0" "mv");
 194
 195 // CHECK-LABEL: a0_ptr:
 196 // CHECK: #APP
 197 // CHECK: mv a0, a0
 198 // CHECK: #NO_APP
 199 check_reg!(a0_ptr ptr "a0" "mv");
 200
 201 // CHECK-LABEL: fa0_f32:
 202 // CHECK: #APP
 203 // CHECK: fmv.s fa0, fa0
 204 // CHECK: #NO_APP
 205 check_reg!(fa0_f32 f32 "fa0" "fmv.s");
 206
 207 // CHECK-LABEL: fa0_f64:
 208 // CHECK: #APP
 209 // CHECK: fmv.d fa0, fa0
 210 // CHECK: #NO_APP
 211 check_reg!(fa0_f64 f64 "fa0" "fmv.d");