Use compiler generated entry point for UEFI

Generate Entry function (`efi_main`) in compiler (similar to how C main
is generated for other targets).
This function passes `[image_handle, system_table]` as argv to Rust
lang_start. Then initialize the global variables from `sys::init`

Signed-off-by: Ayush Singh <[email protected]>

Author: Ayush1325

compiler/rustc_codegen_ssa/src/base.rs

@@ -432,7 +432,10 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     ) -> Bx::Function {
         // The entry function is either `int main(void)` or `int main(int argc, char **argv)`,
         // depending on whether the target needs `argc` and `argv` to be passed in.
-        let llfty = if cx.sess().target.main_needs_argc_argv {
+
+        let llfty = if cx.sess().target.os.contains("uefi") {
+            cx.type_func(&[cx.type_i8p(), cx.type_i8p()], cx.type_isize())
+        } else if cx.sess().target.main_needs_argc_argv {
             cx.type_func(&[cx.type_int(), cx.type_ptr_to(cx.type_i8p())], cx.type_int())
         } else {
             cx.type_func(&[], cx.type_int())
@@ -499,8 +502,12 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         };
 
         let result = bx.call(start_ty, None, start_fn, &args, None);
-        let cast = bx.intcast(result, cx.type_int(), true);
-        bx.ret(cast);
+        if cx.sess().target.os.contains("uefi") {
+            bx.ret(result);
+        } else {
+            let cast = bx.intcast(result, cx.type_int(), true);
+            bx.ret(cast);
+        }
 
         llfn
     }
@@ -511,7 +518,17 @@ fn get_argc_argv<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     cx: &'a Bx::CodegenCx,
     bx: &mut Bx,
 ) -> (Bx::Value, Bx::Value) {
-    if cx.sess().target.main_needs_argc_argv {
+    if cx.sess().target.os.contains("uefi") {
+        let param_handle = bx.get_param(0);
+        let param_system_table = bx.get_param(1);
+        let arg_argc = bx.const_int(cx.type_isize(), 2);
+        let arg_argv = bx.array_alloca(cx.type_i8p(), bx.const_int(cx.type_int(), 2), Align::ONE);
+        bx.store(param_handle, arg_argv, Align::ONE);
+        let arg_argv_el1 =
+            bx.gep(cx.type_ptr_to(cx.type_i8()), arg_argv, &[bx.const_int(cx.type_int(), 1)]);
+        bx.store(param_system_table, arg_argv_el1, Align::ONE);
+        (arg_argc, arg_argv)
+    } else if cx.sess().target.main_needs_argc_argv {
         // Params from native `main()` used as args for rust start function
         let param_argc = bx.get_param(0);
         let param_argv = bx.get_param(1);

compiler/rustc_target/src/spec/mod.rs

@@ -1648,6 +1648,12 @@ pub struct TargetOptions {
     /// `argc` and `argv` values.
     pub main_needs_argc_argv: bool,
 
+    // The name of entry function.
+    pub entry_name: StaticCow<str>,
+
+    // The ABI of entry function.
+    pub entry_abi: Conv,
+
     /// Flag indicating whether #[thread_local] is available for this target.
     pub has_thread_local: bool,
     /// This is mainly for easy compatibility with emscripten.

compiler/rustc_target/src/spec/uefi_msvc_base.rs

@@ -46,6 +46,7 @@ pub fn opts() -> TargetOptions {
         stack_probes: StackProbeType::Call,
         singlethread: true,
         linker: Some("rust-lld".into()),
+        entry_name: "efi_main".into(),
         ..base
     }
 }

compiler/rustc_target/src/spec/x86_64_unknown_uefi.rs

@@ -5,12 +5,13 @@
 // The win64 ABI is used. It differs from the sysv64 ABI, so we must use a windows target with
 // LLVM. "x86_64-unknown-windows" is used to get the minimal subset of windows-specific features.
 
-use crate::spec::Target;
+use crate::{abi::call::Conv, spec::Target};
 
 pub fn target() -> Target {
     let mut base = super::uefi_msvc_base::opts();
     base.cpu = "x86-64".into();
     base.max_atomic_width = Some(64);
+    base.entry_abi = Conv::X86_64Win64;
 
     // We disable MMX and SSE for now, even though UEFI allows using them. Problem is, you have to
     // enable these CPU features explicitly before their first use, otherwise their instructions

library/std/src/sys/uefi/mod.rs

@@ -48,7 +48,12 @@ pub mod memchr {
     pub use core::slice::memchr::{memchr, memrchr};
 }
 
-pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {}
+pub unsafe fn init(argc: isize, argv: *const *const u8, _sigpipe: u8) {
+    assert_eq!(argc, 2);
+    let image_handle = unsafe { NonNull::new(*argv as *mut crate::ffi::c_void).unwrap() };
+    let system_table = unsafe { NonNull::new(*argv.add(1) as *mut crate::ffi::c_void).unwrap() };
+    unsafe { crate::os::uefi::env::init_globals(image_handle, system_table) };
+}
 
 // SAFETY: must be called only once during runtime cleanup.
 // NOTE: this is not guaranteed to run, for example when the program aborts.
@@ -133,26 +138,3 @@ unsafe fn get_random() -> Option<u64> {
     }
     None
 }
-
-// FIXME: Do not generate this in case of `no_main`
-#[no_mangle]
-pub unsafe extern "efiapi" fn efi_main(
-    handle: r_efi::efi::Handle,
-    st: *mut r_efi::efi::SystemTable,
-) -> r_efi::efi::Status {
-    extern "C" {
-        fn main(argc: isize, argv: *const *const u8) -> isize;
-    }
-
-    let (system_table, image_handle) = match (NonNull::new(st), NonNull::new(handle)) {
-        (Some(x), Some(y)) => (x, y),
-        _ => return r_efi::efi::Status::ABORTED,
-    };
-    unsafe { uefi::env::init_globals(image_handle, system_table.cast()) };
-
-    let res = unsafe { main(0, crate::ptr::null()) };
-    match usize::try_from(res) {
-        Ok(x) => r_efi::efi::Status::from_usize(x),
-        Err(_) => r_efi::efi::Status::ABORTED,
-    }
-}

src/test/ui/format-no-std.rs

@@ -1,5 +1,7 @@
 // run-pass
 // ignore-emscripten no no_std executables
+// ignore-uefi allocation and other std functionality is intialized in `sys::init`. This test
+// causes CPU Exception.
 
 #![feature(lang_items, start)]
 #![no_std]

src/test/ui/runtime/native-print-no-runtime.rs

@@ -1,4 +1,6 @@
 // run-pass
+// ignore-uefi allocation and other std functionality is intialized in `sys::init`. This test
+// causes CPU Exception.
 
 #![feature(start)]
 

src/test/ui/runtime/running-with-no-runtime.rs

@@ -1,6 +1,8 @@
 // run-pass
 // ignore-emscripten spawning processes is not supported
 // ignore-sgx no processes
+// ignore-uefi allocation and other std functionality is intialized in `sys::init`. This test
+// causes CPU Exception.
 // revisions: mir thir
 // [thir]compile-flags: -Zthir-unsafeck