From 9621156fc3814edaef6acafc06827e5aa87c9bdd Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Wed, 18 Sep 2013 04:58:52 -0400 Subject: [PATCH] librustc/libstd: No longer pass crate_map to start. --- src/librustc/middle/trans/base.rs | 13 ++++--------- src/librustc/middle/typeck/mod.rs | 3 +-- src/libstd/rt/crate_map.rs | 13 ++++++++++++- src/libstd/rt/logging.rs | 18 ++++++++++++++++++ src/libstd/rt/mod.rs | 31 ++++++++++++++++++++++++++++++- src/libstd/unstable/lang.rs | 14 ++++++++++++++ 6 files changed, 79 insertions(+), 13 deletions(-) diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 4c679798bce..7cc38835ebc 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -2442,11 +2442,6 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext, unsafe { llvm::LLVMPositionBuilderAtEnd(bld, llbb); - let crate_map = ccx.crate_map; - let opaque_crate_map = do "crate_map".with_c_str |buf| { - llvm::LLVMBuildPointerCast(bld, crate_map, Type::i8p().to_ref(), buf) - }; - let (start_fn, args) = if use_start_lang_item { let start_def_id = match ccx.tcx.lang_items.require(StartFnLangItem) { Ok(id) => id, @@ -2469,8 +2464,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext, C_null(Type::opaque_box(ccx).ptr_to()), opaque_rust_main, llvm::LLVMGetParam(llfn, 0), - llvm::LLVMGetParam(llfn, 1), - opaque_crate_map + llvm::LLVMGetParam(llfn, 1) ] }; (start_fn, args) @@ -2479,8 +2473,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext, let args = ~[ C_null(Type::opaque_box(ccx).ptr_to()), llvm::LLVMGetParam(llfn, 0 as c_uint), - llvm::LLVMGetParam(llfn, 1 as c_uint), - opaque_crate_map + llvm::LLVMGetParam(llfn, 1 as c_uint) ]; (rust_main, args) @@ -2659,6 +2652,8 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef { let path = vec::append((*pth).clone(), [path_name(ni.ident)]); foreign::register_foreign_item_fn(ccx, abis, &path, ni) } + ast::foreign_item_static(*) if attr::contains_name(ni.attrs, "crate_map") + => ccx.crate_map, ast::foreign_item_static(*) => { let ident = foreign::link_name(ccx, ni); let g = do ident.with_c_str |buf| { diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 8d7dbdf263e..45a65f954a3 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -402,8 +402,7 @@ fn check_start_fn_ty(ccx: &CrateCtxt, bound_lifetime_names: opt_vec::Empty, inputs: ~[ ty::mk_int(), - ty::mk_imm_ptr(tcx, ty::mk_imm_ptr(tcx, ty::mk_u8())), - ty::mk_imm_ptr(tcx, ty::mk_u8()) + ty::mk_imm_ptr(tcx, ty::mk_imm_ptr(tcx, ty::mk_u8())) ], output: ty::mk_int() } diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs index 270b5e5b137..ee89df2bd96 100644 --- a/src/libstd/rt/crate_map.rs +++ b/src/libstd/rt/crate_map.rs @@ -16,7 +16,13 @@ use vec; use hashmap::HashSet; use container::MutableSet; -pub struct ModEntry{ +extern { + #[cfg(not(stage0))] + #[crate_map] + static CRATE_MAP: CrateMap; +} + +pub struct ModEntry { name: *c_char, log_level: *mut u32 } @@ -34,6 +40,11 @@ struct CrateMap { children: [*CrateMap, ..1] } +#[cfg(not(stage0))] +pub fn get_crate_map() -> *CrateMap { + &'static CRATE_MAP as *CrateMap +} + unsafe fn version(crate_map: *CrateMap) -> i32 { match (*crate_map).version { 1 => return 1, diff --git a/src/libstd/rt/logging.rs b/src/libstd/rt/logging.rs index fbe05267cf4..26072079bcc 100644 --- a/src/libstd/rt/logging.rs +++ b/src/libstd/rt/logging.rs @@ -12,6 +12,7 @@ use libc::{uintptr_t, exit, STDERR_FILENO}; use option::{Some, None, Option}; use rt::util::dumb_println; use rt::crate_map::{ModEntry, iter_crate_map}; +#[cfg(not(stage0))] use rt::crate_map::get_crate_map; use str::StrSlice; use str::raw::from_c_str; use u32; @@ -211,6 +212,7 @@ impl Logger for StdErrLogger { /// Configure logging by traversing the crate map and setting the /// per-module global logging flags based on the logging spec #[fixed_stack_segment] #[inline(never)] +#[cfg(stage0)] pub fn init(crate_map: *u8) { use os; @@ -224,6 +226,22 @@ pub fn init(crate_map: *u8) { } } } +#[cfg(not(stage0))] +pub fn init() { + use os; + + let crate_map = get_crate_map() as *u8; + + let log_spec = os::getenv("RUST_LOG"); + match log_spec { + Some(spec) => { + update_log_settings(crate_map, spec); + } + None => { + update_log_settings(crate_map, ~""); + } + } +} #[fixed_stack_segment] #[inline(never)] pub fn console_on() { unsafe { rust_log_console_on() } } diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 6df857b8d55..1ad258c3edf 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -171,11 +171,11 @@ pub mod borrowck; /// /// * `argc` & `argv` - The argument vector. On Unix this information is used /// by os::args. -/// * `crate_map` - Runtime information about the executing crate, mostly for logging /// /// # Return value /// /// The return value is used as the process return code. 0 on success, 101 on error. +#[cfg(stage0)] pub fn start(argc: int, argv: **u8, crate_map: *u8, main: ~fn()) -> int { init(argc, argv, crate_map); @@ -184,12 +184,22 @@ pub fn start(argc: int, argv: **u8, crate_map: *u8, main: ~fn()) -> int { return exit_code; } +#[cfg(not(stage0))] +pub fn start(argc: int, argv: **u8, main: ~fn()) -> int { + + init(argc, argv); + let exit_code = run(main); + cleanup(); + + return exit_code; +} /// Like `start` but creates an additional scheduler on the current thread, /// which in most cases will be the 'main' thread, and pins the main task to it. /// /// This is appropriate for running code that must execute on the main thread, /// such as the platform event loop and GUI. +#[cfg(stage0)] pub fn start_on_main_thread(argc: int, argv: **u8, crate_map: *u8, main: ~fn()) -> int { init(argc, argv, crate_map); let exit_code = run_on_main_thread(main); @@ -197,12 +207,21 @@ pub fn start_on_main_thread(argc: int, argv: **u8, crate_map: *u8, main: ~fn()) return exit_code; } +#[cfg(not(stage0))] +pub fn start_on_main_thread(argc: int, argv: **u8, main: ~fn()) -> int { + init(argc, argv); + let exit_code = run_on_main_thread(main); + cleanup(); + + return exit_code; +} /// One-time runtime initialization. /// /// Initializes global state, including frobbing /// the crate's logging flags, registering GC /// metadata, and storing the process arguments. +#[cfg(stage0)] pub fn init(argc: int, argv: **u8, crate_map: *u8) { // XXX: Derefing these pointers is not safe. // Need to propagate the unsafety to `start`. @@ -212,6 +231,16 @@ pub fn init(argc: int, argv: **u8, crate_map: *u8) { logging::init(crate_map); } } +#[cfg(not(stage0))] +pub fn init(argc: int, argv: **u8) { + // XXX: Derefing these pointers is not safe. + // Need to propagate the unsafety to `start`. + unsafe { + args::init(argc, argv); + env::init(); + logging::init(); + } +} /// One-time runtime cleanup. pub fn cleanup() { diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs index 1d839b55195..baa70551489 100644 --- a/src/libstd/unstable/lang.rs +++ b/src/libstd/unstable/lang.rs @@ -93,6 +93,7 @@ pub unsafe fn check_not_borrowed(a: *u8, borrowck::check_not_borrowed(a, file, line) } +#[cfg(stage0)] #[lang="start"] pub fn start(main: *u8, argc: int, argv: **c_char, crate_map: *u8) -> int { @@ -105,3 +106,16 @@ pub fn start(main: *u8, argc: int, argv: **c_char, }; } } + +#[cfg(not(stage0))] +#[lang="start"] +pub fn start(main: *u8, argc: int, argv: **c_char) -> int { + use rt; + + unsafe { + return do rt::start(argc, argv as **u8) { + let main: extern "Rust" fn() = transmute(main); + main(); + }; + } +}