Fixes after rebase

1. Another set of fixes needed due to rebase
2. Code Refactoring

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

Author: Ayush1325

Cargo.lock

@@ -5240,9 +5240,9 @@ checksum = "aa7c7f42dea4b1b99439786f5633aeb9c14c1b53f75e282803c2ec2ad545873c"
 
 [[package]]
 name = "tracing"
-version = "0.1.37"
+version = "0.1.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
+checksum = "a400e31aa60b9d44a52a8ee0343b5b18566b03a8321e0d321f695cf56e940160"
 dependencies = [
  "cfg-if 1.0.0",
  "pin-project-lite",
@@ -5252,9 +5252,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.23"
+version = "0.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a"
+checksum = "11c75893af559bc8e10716548bdef5cb2b983f8e637db9d0e15126b61b484ee2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5263,9 +5263,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.30"
+version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
+checksum = "7b7358be39f2f274f322d2aaed611acc57f382e8eb1e5b48cb9ae30933495ce7"
 dependencies = [
  "once_cell",
  "valuable",
@@ -5866,4 +5866,3 @@ dependencies = [
  "syn",
  "synstructure",
 ]
-

compiler/rustc_codegen_ssa/src/base.rs

@@ -522,7 +522,7 @@ fn get_argc_argv<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         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);
+        let arg_argv = bx.alloca(cx.type_array(cx.type_i8p(), 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)]);

compiler/rustc_target/src/spec/mod.rs

@@ -1648,12 +1648,6 @@ 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.

library/std/src/os/mod.rs

@@ -143,14 +143,12 @@ pub mod redox;
 pub mod solaris;
 #[cfg(target_os = "solid_asp3")]
 pub mod solid;
-#[cfg(target_os = "vxworks")]
-pub mod vxworks;
-#[cfg(target_os = "watchos")]
-pub(crate) mod watchos;
 #[cfg(target_os = "uefi")]
 pub mod uefi;
 #[cfg(target_os = "vxworks")]
 pub mod vxworks;
+#[cfg(target_os = "watchos")]
+pub(crate) mod watchos;
 
 #[cfg(any(unix, target_os = "wasi", doc))]
 pub mod fd;

library/std/src/os/uefi/env.rs

@@ -37,23 +37,21 @@ pub fn system_table() -> NonNull<c_void> {
     try_system_table().unwrap()
 }
 
-/// Get the SystemTable Pointer.
-/// This function is mostly intended for places where panic is not an option
-#[unstable(feature = "uefi_std", issue = "100499")]
-pub fn try_system_table() -> Option<NonNull<c_void>> {
-    NonNull::new(GLOBAL_SYSTEM_TABLE.load(Ordering::Acquire))
-}
-
 /// Get the SystemHandle Pointer.
 /// Note: This function panics if the System Table and Image Handle is Not initialized
 #[unstable(feature = "uefi_std", issue = "100499")]
 pub fn image_handle() -> NonNull<c_void> {
     try_image_handle().unwrap()
 }
 
+/// Get the SystemTable Pointer.
+/// This function is mostly intended for places where panic is not an option
+pub(crate) fn try_system_table() -> Option<NonNull<crate::ffi::c_void>> {
+    NonNull::new(GLOBAL_SYSTEM_TABLE.load(Ordering::Acquire))
+}
+
 /// Get the SystemHandle Pointer.
 /// This function is mostly intended for places where panic is not an option
-#[unstable(feature = "uefi_std", issue = "100499")]
-pub fn try_image_handle() -> Option<NonNull<c_void>> {
+pub(crate) fn try_image_handle() -> Option<NonNull<crate::ffi::c_void>> {
     NonNull::new(GLOBAL_IMAGE_HANDLE.load(Ordering::Acquire))
 }

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

@@ -6,7 +6,7 @@ use crate::ffi::OsString;
 use crate::fmt;
 use crate::path::PathBuf;
 use crate::sync::OnceLock;
-use crate::sys_common::args::{parse_lp_cmd_line, WStrUnits};
+use crate::sys_common::wstr::WStrUnits;
 use crate::vec;
 use r_efi::efi::protocols::loaded_image;
 
@@ -35,6 +35,13 @@ pub fn args() -> Args {
     Args { parsed_args_list: vec_args.clone().into_iter() }
 }
 
+pub(crate) fn parse_lp_cmd_line<'a, F: Fn() -> OsString>(
+    _lp_cmd_line: Option<WStrUnits<'a>>,
+    _exe_name: F,
+) -> Vec<OsString> {
+    todo!()
+}
+
 impl fmt::Debug for Args {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.parsed_args_list.as_slice().fmt(f)

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

@@ -1,3 +1,7 @@
+//! Contains most of the shared UEFI specific stuff. Some of this might be moved to `std::os::uefi`
+//! if needed but no point in adding extra public API when there is not Std support for UEFI in the
+//! first place
+
 use r_efi::efi::{EventNotify, Guid, Tpl};
 
 use crate::alloc::{AllocError, Allocator, Global, Layout};

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

@@ -79,3 +79,8 @@ struct UefiBuf {
     pub len: u32,
     pub buf: *mut c_void,
 }
+
+// FIXME: Maybe add std::os::io APIs from Windows.
+pub fn is_terminal<T>(_: T) -> bool {
+    false
+}

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

@@ -91,7 +91,7 @@ pub(crate) fn device_path_to_path(path: &mut device_path::Protocol) -> io::Resul
                 r_efi::efi::Boolean::FALSE,
             )
         };
-        let ucs2_iter = match unsafe { crate::sys_common::args::WStrUnits::new(path_ucs2) } {
+        let ucs2_iter = match unsafe { crate::sys_common::wstr::WStrUnits::new(path_ucs2) } {
             None => break,
             Some(x) => x,
         };

library/std/src/sys/windows/args.rs

@@ -44,6 +44,128 @@ pub fn args() -> Args {
     }
 }
 
+/// Implements the Windows command-line argument parsing algorithm.
+///
+/// Microsoft's documentation for the Windows CLI argument format can be found at
+/// <https://docs.microsoft.com/en-us/cpp/cpp/main-function-command-line-args?view=msvc-160#parsing-c-command-line-arguments>
+///
+/// A more in-depth explanation is here:
+/// <https://daviddeley.com/autohotkey/parameters/parameters.htm#WIN>
+///
+/// Windows includes a function to do command line parsing in shell32.dll.
+/// However, this is not used for two reasons:
+///
+/// 1. Linking with that DLL causes the process to be registered as a GUI application.
+/// GUI applications add a bunch of overhead, even if no windows are drawn. See
+/// <https://randomascii.wordpress.com/2018/12/03/a-not-called-function-can-cause-a-5x-slowdown/>.
+///
+/// 2. It does not follow the modern C/C++ argv rules outlined in the first two links above.
+///
+/// This function was tested for equivalence to the C/C++ parsing rules using an
+/// extensive test suite available at
+/// <https://github.com/ChrisDenton/winarg/tree/std>.
+fn parse_lp_cmd_line<'a, F: Fn() -> OsString>(
+    lp_cmd_line: Option<WStrUnits<'a>>,
+    exe_name: F,
+) -> Vec<OsString> {
+    const BACKSLASH: NonZeroU16 = non_zero_u16(b'\\' as u16);
+    const QUOTE: NonZeroU16 = non_zero_u16(b'"' as u16);
+    const TAB: NonZeroU16 = non_zero_u16(b'\t' as u16);
+    const SPACE: NonZeroU16 = non_zero_u16(b' ' as u16);
+
+    let mut ret_val = Vec::new();
+    // If the cmd line pointer is null or it points to an empty string then
+    // return the name of the executable as argv[0].
+    if lp_cmd_line.as_ref().and_then(|cmd| cmd.peek()).is_none() {
+        ret_val.push(exe_name());
+        return ret_val;
+    }
+    let mut code_units = lp_cmd_line.unwrap();
+
+    // The executable name at the beginning is special.
+    let mut in_quotes = false;
+    let mut cur = Vec::new();
+    for w in &mut code_units {
+        match w {
+            // A quote mark always toggles `in_quotes` no matter what because
+            // there are no escape characters when parsing the executable name.
+            QUOTE => in_quotes = !in_quotes,
+            // If not `in_quotes` then whitespace ends argv[0].
+            SPACE | TAB if !in_quotes => break,
+            // In all other cases the code unit is taken literally.
+            _ => cur.push(w.get()),
+        }
+    }
+    // Skip whitespace.
+    code_units.advance_while(|w| w == SPACE || w == TAB);
+    ret_val.push(OsString::from_wide(&cur));
+
+    // Parse the arguments according to these rules:
+    // * All code units are taken literally except space, tab, quote and backslash.
+    // * When not `in_quotes`, space and tab separate arguments. Consecutive spaces and tabs are
+    // treated as a single separator.
+    // * A space or tab `in_quotes` is taken literally.
+    // * A quote toggles `in_quotes` mode unless it's escaped. An escaped quote is taken literally.
+    // * A quote can be escaped if preceded by an odd number of backslashes.
+    // * If any number of backslashes is immediately followed by a quote then the number of
+    // backslashes is halved (rounding down).
+    // * Backslashes not followed by a quote are all taken literally.
+    // * If `in_quotes` then a quote can also be escaped using another quote
+    // (i.e. two consecutive quotes become one literal quote).
+    let mut cur = Vec::new();
+    let mut in_quotes = false;
+    while let Some(w) = code_units.next() {
+        match w {
+            // If not `in_quotes`, a space or tab ends the argument.
+            SPACE | TAB if !in_quotes => {
+                ret_val.push(OsString::from_wide(&cur[..]));
+                cur.truncate(0);
+
+                // Skip whitespace.
+                code_units.advance_while(|w| w == SPACE || w == TAB);
+            }
+            // Backslashes can escape quotes or backslashes but only if consecutive backslashes are followed by a quote.
+            BACKSLASH => {
+                let backslash_count = code_units.advance_while(|w| w == BACKSLASH) + 1;
+                if code_units.peek() == Some(QUOTE) {
+                    cur.extend(iter::repeat(BACKSLASH.get()).take(backslash_count / 2));
+                    // The quote is escaped if there are an odd number of backslashes.
+                    if backslash_count % 2 == 1 {
+                        code_units.next();
+                        cur.push(QUOTE.get());
+                    }
+                } else {
+                    // If there is no quote on the end then there is no escaping.
+                    cur.extend(iter::repeat(BACKSLASH.get()).take(backslash_count));
+                }
+            }
+            // If `in_quotes` and not backslash escaped (see above) then a quote either
+            // unsets `in_quote` or is escaped by another quote.
+            QUOTE if in_quotes => match code_units.peek() {
+                // Two consecutive quotes when `in_quotes` produces one literal quote.
+                Some(QUOTE) => {
+                    cur.push(QUOTE.get());
+                    code_units.next();
+                }
+                // Otherwise set `in_quotes`.
+                Some(_) => in_quotes = false,
+                // The end of the command line.
+                // Push `cur` even if empty, which we do by breaking while `in_quotes` is still set.
+                None => break,
+            },
+            // If not `in_quotes` and not BACKSLASH escaped (see above) then a quote sets `in_quote`.
+            QUOTE => in_quotes = true,
+            // Everything else is always taken literally.
+            _ => cur.push(w.get()),
+        }
+    }
+    // Push the final argument, if any.
+    if !cur.is_empty() || in_quotes {
+        ret_val.push(OsString::from_wide(&cur[..]));
+    }
+    ret_val
+}
+
 pub struct Args {
     parsed_args_list: vec::IntoIter<OsString>,
 }