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

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