example/mini_core_hello_world.rs

   1 // Adapted from https://github.com/sunfishcode/mir2cranelift/blob/master/rust-examples/nocore-hello-world.rs
   2
   3 #![feature(no_core, unboxed_closures, start, lang_items, box_syntax)]
   4 #![no_core]
   5 #![allow(dead_code)]
   6
   7 extern crate mini_core;
   8
   9 use mini_core::*;
  10
  11 #[link(name = "c")]
  12 extern "C" {
  13     fn puts(s: *const u8);
  14 }
  15
  16 unsafe extern "C" fn my_puts(s: *const u8) {
  17     puts(s);
  18 }
  19
  20 // TODO remove when jit supports linking rlibs
  21 #[cfg(jit)]
  22 extern "C" fn panic<T>(_: T) -> ! {
  23     unsafe {
  24         intrinsics::abort();
  25     }
  26 }
  27
  28 #[lang = "termination"]
  29 trait Termination {
  30     fn report(self) -> i32;
  31 }
  32
  33 impl Termination for () {
  34     fn report(self) -> i32 {
  35         unsafe {
  36             NUM = 6 * 7 + 1 + (1u8 == 1u8) as u8; // 44
  37             *NUM_REF as i32
  38         }
  39     }
  40 }
  41
  42 trait SomeTrait {
  43     fn object_safe(&self);
  44 }
  45
  46 impl SomeTrait for &'static str {
  47     fn object_safe(&self) {
  48         unsafe {
  49             puts(*self as *const str as *const u8);
  50         }
  51     }
  52 }
  53
  54 struct NoisyDrop {
  55     text: &'static str,
  56     inner: NoisyDropInner,
  57 }
  58
  59 struct NoisyDropInner;
  60
  61 impl Drop for NoisyDrop {
  62     fn drop(&mut self) {
  63         unsafe {
  64             puts(self.text as *const str as *const u8);
  65         }
  66     }
  67 }
  68
  69 impl Drop for NoisyDropInner {
  70     fn drop(&mut self) {
  71         unsafe {
  72             puts("Inner got dropped!\0" as *const str as *const u8);
  73         }
  74     }
  75 }
  76
  77 enum Ordering {
  78     Less = -1,
  79     Equal = 0,
  80     Greater = 1,
  81 }
  82
  83 #[lang = "start"]
  84 fn start<T: Termination + 'static>(
  85     main: fn() -> T,
  86     _argc: isize,
  87     _argv: *const *const u8,
  88 ) -> isize {
  89     main().report() as isize
  90 }
  91
  92 static mut NUM: u8 = 6 * 7;
  93 static NUM_REF: &'static u8 = unsafe { &NUM };
  94
  95 macro_rules! assert {
  96     ($e:expr) => {
  97         if !$e {
  98             panic(&(stringify!(! $e), file!(), line!(), 0));
  99         }
 100     };
 101 }
 102
 103 macro_rules! assert_eq {
 104     ($l:expr, $r: expr) => {
 105         if $l != $r {
 106             panic(&(stringify!($l != $r), file!(), line!(), 0));
 107         }
 108     }
 109 }
 110
 111 struct Unique<T: ?Sized> {
 112     pointer: *const T,
 113     _marker: PhantomData<T>,
 114 }
 115
 116 impl<T: ?Sized, U: ?Sized> CoerceUnsized<Unique<U>> for Unique<T> where T: Unsize<U> {}
 117
 118 fn main() {
 119     unsafe {
 120         let hello: &[u8] = b"Hello\0" as &[u8; 6];
 121         let ptr: *const u8 = hello as *const [u8] as *const u8;
 122         puts(ptr);
 123
 124         // TODO remove when jit supports linking rlibs
 125         #[cfg(not(jit))]
 126         {
 127             let world: Box<&str> = box "World!\0";
 128             puts(*world as *const str as *const u8);
 129             world as Box<SomeTrait>;
 130         }
 131
 132         assert_eq!(intrinsics::size_of_val(hello) as u8, 6);
 133
 134         let chars = &['C', 'h', 'a', 'r', 's'];
 135         let chars = chars as &[char];
 136         assert_eq!(intrinsics::size_of_val(chars) as u8, 4 * 5);
 137
 138         let a: &dyn SomeTrait = &"abc\0";
 139         a.object_safe();
 140
 141         assert_eq!(intrinsics::size_of_val(a) as u8, 16);
 142         assert_eq!(intrinsics::size_of_val(&0u32) as u8, 4);
 143
 144         assert_eq!(intrinsics::min_align_of::<u16>() as u8, 2);
 145         assert_eq!(intrinsics::min_align_of_val(&a) as u8, intrinsics::min_align_of::<&str>() as u8);
 146
 147         assert!(!intrinsics::needs_drop::<u8>());
 148         assert!(intrinsics::needs_drop::<NoisyDrop>());
 149
 150         Unique {
 151             pointer: 0 as *const &str,
 152             _marker: PhantomData,
 153         } as Unique<dyn SomeTrait>;
 154     }
 155
 156     let _ = NoisyDrop {
 157         text: "Outer got dropped!\0",
 158         inner: NoisyDropInner,
 159     };
 160
 161     const FUNC_REF: Option<fn()> = Some(main);
 162     match FUNC_REF {
 163         Some(_) => {},
 164         None => assert!(false),
 165     }
 166
 167     match Ordering::Less {
 168         Ordering::Less => {},
 169         _ => assert!(false),
 170     }
 171
 172     [NoisyDropInner, NoisyDropInner];
 173 }