library/rtstartup/rsbegin.rs

   1 // rsbegin.o and rsend.o are the so called "compiler runtime startup objects".
   2 // They contain code needed to correctly initialize the compiler runtime.
   3 //
   4 // When an executable or dylib image is linked, all user code and libraries are
   5 // "sandwiched" between these two object files, so code or data from rsbegin.o
   6 // become first in the respective sections of the image, whereas code and data
   7 // from rsend.o become the last ones. This effect can be used to place symbols
   8 // at the beginning or at the end of a section, as well as to insert any required
   9 // headers or footers.
  10 //
  11 // Note that the actual module entry point is located in the C runtime startup
  12 // object (usually called `crtX.o`), which then invokes initialization callbacks
  13 // of other runtime components (registered via yet another special image section).
  14
  15 #![feature(no_core)]
  16 #![feature(lang_items)]
  17 #![feature(auto_traits)]
  18 #![crate_type = "rlib"]
  19 #![no_core]
  20 #![allow(non_camel_case_types)]
  21
  22 #[lang = "sized"]
  23 trait Sized {}
  24 #[lang = "sync"]
  25 auto trait Sync {}
  26 #[lang = "copy"]
  27 trait Copy {}
  28 #[lang = "freeze"]
  29 auto trait Freeze {}
  30
  31 #[lang = "drop_in_place"]
  32 #[inline]
  33 #[allow(unconditional_recursion)]
  34 pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
  35     drop_in_place(to_drop);
  36 }
  37
  38 // Frame unwind info registration
  39 //
  40 // Each module's image contains a frame unwind info section (usually
  41 // ".eh_frame").  When a module is loaded/unloaded into the process, the
  42 // unwinder must be informed about the location of this section in memory. The
  43 // methods of achieving that vary by the platform.  On some (e.g., Linux), the
  44 // unwinder can discover unwind info sections on its own (by dynamically
  45 // enumerating currently loaded modules via the dl_iterate_phdr() API and
  46 // finding their ".eh_frame" sections); Others, like Windows, require modules
  47 // to actively register their unwind info sections via unwinder API.
  48 #[cfg(all(target_os = "windows", target_arch = "x86", target_env = "gnu"))]
  49 pub mod eh_frames {
  50     #[no_mangle]
  51     #[link_section = ".eh_frame"]
  52     // Marks beginning of the stack frame unwind info section
  53     pub static __EH_FRAME_BEGIN__: [u8; 0] = [];
  54
  55     // Scratch space for unwinder's internal book-keeping.
  56     // This is defined as `struct object` in $GCC/libgcc/unwind-dw2-fde.h.
  57     static mut OBJ: [isize; 6] = [0; 6];
  58
  59     macro_rules! impl_copy {
  60         ($($t:ty)*) => {
  61             $(
  62                 impl ::Copy for $t {}
  63             )*
  64         }
  65     }
  66
  67     impl_copy! {
  68         usize u8 u16 u32 u64 u128
  69         isize i8 i16 i32 i64 i128
  70         f32 f64
  71         bool char
  72     }
  73
  74     // Unwind info registration/deregistration routines.
  75     extern "C" {
  76         fn __register_frame_info(eh_frame_begin: *const u8, object: *mut u8);
  77         fn __deregister_frame_info(eh_frame_begin: *const u8, object: *mut u8);
  78     }
  79
  80     unsafe extern "C" fn init() {
  81         // register unwind info on module startup
  82         __register_frame_info(&__EH_FRAME_BEGIN__ as *const u8, &mut OBJ as *mut _ as *mut u8);
  83     }
  84
  85     unsafe extern "C" fn uninit() {
  86         // unregister on shutdown
  87         __deregister_frame_info(&__EH_FRAME_BEGIN__ as *const u8, &mut OBJ as *mut _ as *mut u8);
  88     }
  89
  90     // MinGW-specific init/uninit routine registration
  91     pub mod mingw_init {
  92         // MinGW's startup objects (crt0.o / dllcrt0.o) will invoke global constructors in the
  93         // .ctors and .dtors sections on startup and exit. In the case of DLLs, this is done when
  94         // the DLL is loaded and unloaded.
  95         //
  96         // The linker will sort the sections, which ensures that our callbacks are located at the
  97         // end of the list. Since constructors are run in reverse order, this ensures that our
  98         // callbacks are the first and last ones executed.
  99
 100         #[link_section = ".ctors.65535"] // .ctors.* : C initialization callbacks
 101         pub static P_INIT: unsafe extern "C" fn() = super::init;
 102
 103         #[link_section = ".dtors.65535"] // .dtors.* : C termination callbacks
 104         pub static P_UNINIT: unsafe extern "C" fn() = super::uninit;
 105     }
 106 }