compiler/rustc_codegen_cranelift/example/example.rs

   1 #![feature(no_core, unboxed_closures)]
   2 #![no_core]
   3 #![allow(dead_code)]
   4
   5 extern crate mini_core;
   6
   7 use mini_core::*;
   8
   9 pub fn abc(a: u8) -> u8 {
  10     a * 2
  11 }
  12
  13 pub fn bcd(b: bool, a: u8) -> u8 {
  14     if b {
  15         a * 2
  16     } else {
  17         a * 3
  18     }
  19 }
  20
  21 pub fn call() {
  22     abc(42);
  23 }
  24
  25 pub fn indirect_call() {
  26     let f: fn() = call;
  27     f();
  28 }
  29
  30 pub enum BoolOption {
  31     Some(bool),
  32     None,
  33 }
  34
  35 pub fn option_unwrap_or(o: BoolOption, d: bool) -> bool {
  36     match o {
  37         BoolOption::Some(b) => b,
  38         BoolOption::None => d,
  39     }
  40 }
  41
  42 pub fn ret_42() -> u8 {
  43     42
  44 }
  45
  46 pub fn return_str() -> &'static str {
  47     "hello world"
  48 }
  49
  50 pub fn promoted_val() -> &'static u8 {
  51     &(1 * 2)
  52 }
  53
  54 pub fn cast_ref_to_raw_ptr(abc: &u8) -> *const u8 {
  55     abc as *const u8
  56 }
  57
  58 pub fn cmp_raw_ptr(a: *const u8, b: *const u8) -> bool {
  59     a == b
  60 }
  61
  62 pub fn int_cast(a: u16, b: i16) -> (u8, u16, u32, usize, i8, i16, i32, isize, u8, u32) {
  63     (
  64         a as u8, a as u16, a as u32, a as usize, a as i8, a as i16, a as i32, a as isize, b as u8,
  65         b as u32,
  66     )
  67 }
  68
  69 pub fn char_cast(c: char) -> u8 {
  70     c as u8
  71 }
  72
  73 pub struct DebugTuple(());
  74
  75 pub fn debug_tuple() -> DebugTuple {
  76     DebugTuple(())
  77 }
  78
  79 pub fn size_of<T>() -> usize {
  80     intrinsics::size_of::<T>()
  81 }
  82
  83 pub fn use_size_of() -> usize {
  84     size_of::<u64>()
  85 }
  86
  87 pub unsafe fn use_copy_intrinsic(src: *const u8, dst: *mut u8) {
  88     intrinsics::copy::<u8>(src, dst, 1);
  89 }
  90
  91 pub unsafe fn use_copy_intrinsic_ref(src: *const u8, dst: *mut u8) {
  92     let copy2 = &intrinsics::copy::<u8>;
  93     copy2(src, dst, 1);
  94 }
  95
  96 pub const ABC: u8 = 6 * 7;
  97
  98 pub fn use_const() -> u8 {
  99     ABC
 100 }
 101
 102 pub fn call_closure_3arg() {
 103     (|_, _, _| {})(0u8, 42u16, 0u8)
 104 }
 105
 106 pub fn call_closure_2arg() {
 107     (|_, _| {})(0u8, 42u16)
 108 }
 109
 110 pub struct IsNotEmpty;
 111
 112 impl<'a, 'b> FnOnce<(&'a &'b [u16],)> for IsNotEmpty {
 113     type Output = (u8, u8);
 114
 115     #[inline]
 116     extern "rust-call" fn call_once(mut self, arg: (&'a &'b [u16],)) -> (u8, u8) {
 117         self.call_mut(arg)
 118     }
 119 }
 120
 121 impl<'a, 'b> FnMut<(&'a &'b [u16],)> for IsNotEmpty {
 122     #[inline]
 123     extern "rust-call" fn call_mut(&mut self, _arg: (&'a &'b [u16],)) -> (u8, u8) {
 124         (0, 42)
 125     }
 126 }
 127
 128 pub fn call_is_not_empty() {
 129     IsNotEmpty.call_once((&(&[0u16] as &[_]),));
 130 }
 131
 132 pub fn eq_char(a: char, b: char) -> bool {
 133     a == b
 134 }
 135
 136 pub unsafe fn transmute(c: char) -> u32 {
 137     intrinsics::transmute(c)
 138 }
 139
 140 pub unsafe fn deref_str_ptr(s: *const str) -> &'static str {
 141     &*s
 142 }
 143
 144 pub fn use_array(arr: [u8; 3]) -> u8 {
 145     arr[1]
 146 }
 147
 148 pub fn repeat_array() -> [u8; 3] {
 149     [0; 3]
 150 }
 151
 152 pub fn array_as_slice(arr: &[u8; 3]) -> &[u8] {
 153     arr
 154 }
 155
 156 pub unsafe fn use_ctlz_nonzero(a: u16) -> u16 {
 157     intrinsics::ctlz_nonzero(a)
 158 }
 159
 160 pub fn ptr_as_usize(ptr: *const u8) -> usize {
 161     ptr as usize
 162 }
 163
 164 pub fn float_cast(a: f32, b: f64) -> (f64, f32) {
 165     (a as f64, b as f32)
 166 }
 167
 168 pub fn int_to_float(a: u8, b: i32) -> (f64, f32) {
 169     (a as f64, b as f32)
 170 }
 171
 172 pub fn make_array() -> [u8; 3] {
 173     [42, 0, 5]
 174 }
 175
 176 pub fn some_promoted_tuple() -> &'static (&'static str, &'static str) {
 177     &("abc", "some")
 178 }
 179
 180 pub fn index_slice(s: &[u8]) -> u8 {
 181     s[2]
 182 }
 183
 184 pub struct StrWrapper {
 185     s: str,
 186 }
 187
 188 pub fn str_wrapper_get(w: &StrWrapper) -> &str {
 189     &w.s
 190 }
 191
 192 pub fn i16_as_i8(a: i16) -> i8 {
 193     a as i8
 194 }
 195
 196 pub struct Unsized(u8, str);
 197
 198 pub fn get_sized_field_ref_from_unsized_type(u: &Unsized) -> &u8 {
 199     &u.0
 200 }
 201
 202 pub fn get_unsized_field_ref_from_unsized_type(u: &Unsized) -> &str {
 203     &u.1
 204 }
 205
 206 pub fn reuse_byref_argument_storage(a: (u8, u16, u32)) -> u8 {
 207     a.0
 208 }