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

   1 // assembly-output: emit-asm
   2 // compile-flags: --target hexagon-unknown-linux-musl
   3 // needs-llvm-components: hexagon
   4
   5 #![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch)]
   6 #![crate_type = "rlib"]
   7 #![no_core]
   8 #![allow(asm_sub_register, 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 #[rustc_builtin_macro]
  19 macro_rules! stringify {
  20     () => {};
  21 }
  22
  23 #[lang = "sized"]
  24 trait Sized {}
  25 #[lang = "copy"]
  26 trait Copy {}
  27
  28 type ptr = *const i32;
  29
  30 impl Copy for i8 {}
  31 impl Copy for i16 {}
  32 impl Copy for i32 {}
  33 impl Copy for f32 {}
  34 impl Copy for ptr {}
  35 extern "C" {
  36     fn extern_func();
  37     static extern_static: u8;
  38 }
  39
  40 macro_rules! check {
  41     ($func:ident $ty:ident $class:ident) => {
  42         #[no_mangle]
  43         pub unsafe fn $func(x: $ty) -> $ty {
  44             // Hack to avoid function merging
  45             extern "Rust" {
  46                 fn dont_merge(s: &str);
  47             }
  48             dont_merge(stringify!($func));
  49
  50             let y;
  51             asm!("{} = {}", out($class) y, in($class) x);
  52             y
  53         }
  54     };
  55 }
  56
  57 macro_rules! check_reg {
  58     ($func:ident $ty:ident $reg:tt) => {
  59         #[no_mangle]
  60         pub unsafe fn $func(x: $ty) -> $ty {
  61             // Hack to avoid function merging
  62             extern "Rust" {
  63                 fn dont_merge(s: &str);
  64             }
  65             dont_merge(stringify!($func));
  66
  67             let y;
  68             asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x);
  69             y
  70         }
  71     };
  72 }
  73
  74 // CHECK-LABEL: sym_static:
  75 // CHECK: InlineAsm Start
  76 // CHECK: r0 = {{#+}}extern_static
  77 // CHECK: InlineAsm End
  78 #[no_mangle]
  79 pub unsafe fn sym_static() {
  80     // Hack to avoid function merging
  81     extern "Rust" {
  82         fn dont_merge(s: &str);
  83     }
  84     dont_merge(stringify!($func));
  85
  86     asm!("r0 = #{}", sym extern_static);
  87 }
  88
  89 // CHECK-LABEL: sym_fn:
  90 // CHECK: InlineAsm Start
  91 // CHECK: r0 = {{#+}}extern_func
  92 // CHECK: InlineAsm End
  93 #[no_mangle]
  94 pub unsafe fn sym_fn() {
  95     // Hack to avoid function merging
  96     extern "Rust" {
  97         fn dont_merge(s: &str);
  98     }
  99     dont_merge(stringify!($func));
 100
 101     asm!("r0 = #{}", sym extern_func);
 102 }
 103
 104 // This is a test for multi-instruction packets,
 105 // which require the escaped braces.
 106 //
 107 // CHECK-LABEL: packet:
 108 // CHECK: InlineAsm Start
 109 // CHECK: {
 110 // CHECK:   r{{[0-9]+}} = r0
 111 // CHECK:   memw(r1{{(\+#0)?}}) = r{{[0-9]+}}
 112 // CHECK: }
 113 // CHECK: InlineAsm End
 114 #[no_mangle]
 115 pub unsafe fn packet() {
 116     let val = 1024;
 117     asm!("{{
 118         {} = r0
 119         memw(r1) = {}
 120     }}", out(reg) _, in(reg) &val);
 121 }
 122
 123 // CHECK-LABEL: reg_ptr:
 124 // CHECK: InlineAsm Start
 125 // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
 126 // CHECK: InlineAsm End
 127 check!(reg_ptr ptr reg);
 128
 129 // CHECK-LABEL: reg_f32:
 130 // CHECK: InlineAsm Start
 131 // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
 132 // CHECK: InlineAsm End
 133 check!(reg_f32 f32 reg);
 134
 135 // CHECK-LABEL: reg_i32:
 136 // CHECK: InlineAsm Start
 137 // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
 138 // CHECK: InlineAsm End
 139 check!(reg_i32 i32 reg);
 140
 141 // CHECK-LABEL: reg_i8:
 142 // CHECK: InlineAsm Start
 143 // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
 144 // CHECK: InlineAsm End
 145 check!(reg_i8 i8 reg);
 146
 147 // CHECK-LABEL: reg_i16:
 148 // CHECK: InlineAsm Start
 149 // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
 150 // CHECK: InlineAsm End
 151 check!(reg_i16 i16 reg);
 152
 153 // CHECK-LABEL: r0_ptr:
 154 // CHECK: InlineAsm Start
 155 // CHECK: r0 = r0
 156 // CHECK: InlineAsm End
 157 check_reg!(r0_ptr ptr "r0");
 158
 159 // CHECK-LABEL: r0_f32:
 160 // CHECK: InlineAsm Start
 161 // CHECK: r0 = r0
 162 // CHECK: InlineAsm End
 163 check_reg!(r0_f32 f32 "r0");
 164
 165 // CHECK-LABEL: r0_i32:
 166 // CHECK: InlineAsm Start
 167 // CHECK: r0 = r0
 168 // CHECK: InlineAsm End
 169 check_reg!(r0_i32 i32 "r0");
 170
 171 // CHECK-LABEL: r0_i8:
 172 // CHECK: InlineAsm Start
 173 // CHECK: r0 = r0
 174 // CHECK: InlineAsm End
 175 check_reg!(r0_i8 i8 "r0");
 176
 177 // CHECK-LABEL: r0_i16:
 178 // CHECK: InlineAsm Start
 179 // CHECK: r0 = r0
 180 // CHECK: InlineAsm End
 181 check_reg!(r0_i16 i16 "r0");