auto merge of #10758 : alexcrichton/rust/upgrade-llvm, r=alexcrichton

This upgrades LLVM in order to make progress on #10708, and it's also been awhile since we last upgraded!

The contentious point of this upgrade is that all JIT support has been removed because LLVM is changing it and we're not keeping up with it.

Author: bors

mk/llvm.mk

@@ -37,7 +37,9 @@ endif
 # dependencies. In these cases, commit a change that touches
 # the stamp in the source dir.
 $$(LLVM_STAMP_$(1)): $(S)src/rustllvm/llvm-auto-clean-trigger
+	@$$(call E, make: cleaning llvm)
 	$(Q)$(MAKE) clean-llvm
+	@$$(call E, make: done cleaning llvm)
 	touch $$@
 
 endef

src/librustc/back/link.rs

@@ -82,111 +82,8 @@ pub fn WriteOutputFile(
     }
 }
 
-pub mod jit {
-
-    use back::link::llvm_err;
-    use driver::session::Session;
-    use lib::llvm::llvm;
-    use lib::llvm::{ModuleRef, ContextRef, ExecutionEngineRef};
-
-    use std::c_str::ToCStr;
-    use std::cast;
-    use std::local_data;
-    use std::unstable::intrinsics;
-
-    struct LLVMJITData {
-        ee: ExecutionEngineRef,
-        llcx: ContextRef
-    }
-
-    pub trait Engine {}
-    impl Engine for LLVMJITData {}
-
-    impl Drop for LLVMJITData {
-        fn drop(&mut self) {
-            unsafe {
-                llvm::LLVMDisposeExecutionEngine(self.ee);
-                llvm::LLVMContextDispose(self.llcx);
-            }
-        }
-    }
-
-    pub fn exec(sess: Session,
-                c: ContextRef,
-                m: ModuleRef,
-                stacks: bool) {
-        unsafe {
-            let manager = llvm::LLVMRustPrepareJIT(intrinsics::morestack_addr());
-
-            // We need to tell JIT where to resolve all linked
-            // symbols from. The equivalent of -lstd, -lcore, etc.
-            // By default the JIT will resolve symbols from the extra and
-            // core linked into rustc. We don't want that,
-            // incase the user wants to use an older extra library.
-
-            // We custom-build a JIT execution engine via some rust wrappers
-            // first. This wrappers takes ownership of the module passed in.
-            let ee = llvm::LLVMRustBuildJIT(manager, m, stacks);
-            if ee.is_null() {
-                llvm::LLVMContextDispose(c);
-                llvm_err(sess, ~"Could not create the JIT");
-            }
-
-            // Next, we need to get a handle on the _rust_main function by
-            // looking up it's corresponding ValueRef and then requesting that
-            // the execution engine compiles the function.
-            let fun = "_rust_main".with_c_str(|entry| {
-                llvm::LLVMGetNamedFunction(m, entry)
-            });
-            if fun.is_null() {
-                llvm::LLVMDisposeExecutionEngine(ee);
-                llvm::LLVMContextDispose(c);
-                llvm_err(sess, ~"Could not find _rust_main in the JIT");
-            }
-
-            // Finally, once we have the pointer to the code, we can do some
-            // closure magic here to turn it straight into a callable rust
-            // closure
-            let code = llvm::LLVMGetPointerToGlobal(ee, fun);
-            assert!(!code.is_null());
-            let func: extern "Rust" fn() = cast::transmute(code);
-            func();
-
-            // Currently there is no method of re-using the executing engine
-            // from LLVM in another call to the JIT. While this kinda defeats
-            // the purpose of having a JIT in the first place, there isn't
-            // actually much code currently which would re-use data between
-            // different invocations of this. Additionally, the compilation
-            // model currently isn't designed to support this scenario.
-            //
-            // We can't destroy the engine/context immediately here, however,
-            // because of annihilation. The JIT code contains drop glue for any
-            // types defined in the crate we just ran, and if any of those boxes
-            // are going to be dropped during annihilation, the drop glue must
-            // be run. Hence, we need to transfer ownership of this jit engine
-            // to the caller of this function. To be convenient for now, we
-            // shove it into TLS and have someone else remove it later on.
-            let data = ~LLVMJITData { ee: ee, llcx: c };
-            set_engine(data as ~Engine);
-        }
-    }
-
-    // The stage1 compiler won't work, but that doesn't really matter. TLS
-    // changed only very recently to allow storage of owned values.
-    local_data_key!(engine_key: ~Engine)
-
-    fn set_engine(engine: ~Engine) {
-        local_data::set(engine_key, engine)
-    }
-
-    pub fn consume_engine() -> Option<~Engine> {
-        local_data::pop(engine_key)
-    }
-}
-
 pub mod write {
 
-    use back::link::jit;
     use back::link::{WriteOutputFile, output_type};
     use back::link::{output_type_assembly, output_type_bitcode};
     use back::link::{output_type_exe, output_type_llvm_assembly};
@@ -307,48 +204,38 @@ pub mod write {
                 })
             }
 
-            if sess.opts.jit {
-                // If we are using JIT, go ahead and create and execute the
-                // engine now. JIT execution takes ownership of the module and
-                // context, so don't dispose
-                jit::exec(sess, llcx, llmod, true);
-            } else {
-                // Create a codegen-specific pass manager to emit the actual
-                // assembly or object files. This may not end up getting used,
-                // but we make it anyway for good measure.
-                let cpm = llvm::LLVMCreatePassManager();
-                llvm::LLVMRustAddAnalysisPasses(tm, cpm, llmod);
-                llvm::LLVMRustAddLibraryInfo(cpm, llmod);
-
-                match output_type {
-                    output_type_none => {}
-                    output_type_bitcode => {
-                        output.with_c_str(|buf| {
-                            llvm::LLVMWriteBitcodeToFile(llmod, buf);
-                        })
-                    }
-                    output_type_llvm_assembly => {
-                        output.with_c_str(|output| {
-                            llvm::LLVMRustPrintModule(cpm, llmod, output)
-                        })
-                    }
-                    output_type_assembly => {
-                        WriteOutputFile(sess, tm, cpm, llmod, output, lib::llvm::AssemblyFile);
-                    }
-                    output_type_exe | output_type_object => {
-                        WriteOutputFile(sess, tm, cpm, llmod, output, lib::llvm::ObjectFile);
-                    }
+            // Create a codegen-specific pass manager to emit the actual
+            // assembly or object files. This may not end up getting used,
+            // but we make it anyway for good measure.
+            let cpm = llvm::LLVMCreatePassManager();
+            llvm::LLVMRustAddAnalysisPasses(tm, cpm, llmod);
+            llvm::LLVMRustAddLibraryInfo(cpm, llmod);
+
+            match output_type {
+                output_type_none => {}
+                output_type_bitcode => {
+                    output.with_c_str(|buf| {
+                        llvm::LLVMWriteBitcodeToFile(llmod, buf);
+                    })
+                }
+                output_type_llvm_assembly => {
+                    output.with_c_str(|output| {
+                        llvm::LLVMRustPrintModule(cpm, llmod, output)
+                    })
+                }
+                output_type_assembly => {
+                    WriteOutputFile(sess, tm, cpm, llmod, output, lib::llvm::AssemblyFile);
+                }
+                output_type_exe | output_type_object => {
+                    WriteOutputFile(sess, tm, cpm, llmod, output, lib::llvm::ObjectFile);
                 }
-
-                llvm::LLVMDisposePassManager(cpm);
             }
 
+            llvm::LLVMDisposePassManager(cpm);
+
             llvm::LLVMRustDisposeTargetMachine(tm);
-            // the jit takes ownership of these two items
-            if !sess.opts.jit {
-                llvm::LLVMDisposeModule(llmod);
-                llvm::LLVMContextDispose(llcx);
-            }
+            llvm::LLVMDisposeModule(llmod);
+            llvm::LLVMContextDispose(llcx);
             if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); }
         }
     }
@@ -711,8 +598,8 @@ pub fn sanitize(s: &str) -> ~str {
             ',' => result.push_str("$C$"),
 
             // '.' doesn't occur in types and functions, so reuse it
-            // for ':'
-            ':' => result.push_char('.'),
+            // for ':' and '-'
+            '-' | ':' => result.push_char('.'),
 
             // These are legal symbols
             'a' .. 'z'

src/librustc/back/upcall.rs

@@ -15,22 +15,10 @@ use middle::trans::type_::Type;
 use lib::llvm::{ModuleRef, ValueRef};
 
 pub struct Upcalls {
-    trace: ValueRef,
     rust_personality: ValueRef,
-    reset_stack_limit: ValueRef
 }
 
 macro_rules! upcall (
-    (fn $name:ident($($arg:expr),+) -> $ret:expr) => ({
-        let fn_ty = Type::func([ $($arg),* ], &$ret);
-        base::decl_cdecl_fn(llmod, ~"upcall_" + stringify!($name), fn_ty)
-    });
-    (nothrow fn $name:ident($($arg:expr),+) -> $ret:expr) => ({
-        let fn_ty = Type::func([ $($arg),* ], &$ret);
-        let decl = base::decl_cdecl_fn(llmod, ~"upcall_" + stringify!($name), fn_ty);
-        base::set_no_unwind(decl);
-        decl
-    });
     (nothrow fn $name:ident -> $ret:expr) => ({
         let fn_ty = Type::func([], &$ret);
         let decl = base::decl_cdecl_fn(llmod, ~"upcall_" + stringify!($name), fn_ty);
@@ -39,13 +27,9 @@ macro_rules! upcall (
     })
 )
 
-pub fn declare_upcalls(targ_cfg: @session::config, llmod: ModuleRef) -> @Upcalls {
-    let opaque_ptr = Type::i8().ptr_to();
-    let int_ty = Type::int(targ_cfg.arch);
-
+pub fn declare_upcalls(_targ_cfg: @session::config,
+                       llmod: ModuleRef) -> @Upcalls {
     @Upcalls {
-        trace: upcall!(fn trace(opaque_ptr, opaque_ptr, int_ty) -> Type::void()),
         rust_personality: upcall!(nothrow fn rust_personality -> Type::i32()),
-        reset_stack_limit: upcall!(nothrow fn reset_stack_limit -> Type::void())
     }
 }

src/librustc/driver/driver.rs

@@ -419,11 +419,6 @@ pub fn stop_after_phase_5(sess: Session) -> bool {
         debug!("not building executable, returning early from compile_input");
         return true;
     }
-
-    if sess.opts.jit {
-        debug!("running JIT, returning early from compile_input");
-        return true;
-    }
     return false;
 }
 
@@ -751,7 +746,6 @@ pub fn build_session_options(binary: @str,
         } else { No }
     };
     let gc = debugging_opts & session::gc != 0;
-    let jit = debugging_opts & session::jit != 0;
     let extra_debuginfo = debugging_opts & session::extra_debug_info != 0;
     let debuginfo = debugging_opts & session::debug_info != 0 ||
         extra_debuginfo;
@@ -802,7 +796,6 @@ pub fn build_session_options(binary: @str,
         extra_debuginfo: extra_debuginfo,
         lint_opts: lint_opts,
         save_temps: save_temps,
-        jit: jit,
         output_type: output_type,
         addl_lib_search_paths: @mut addl_lib_search_paths,
         ar: ar,

src/librustc/driver/session.rs

@@ -44,30 +44,28 @@ pub static time_llvm_passes:        uint = 1 <<  3;
 pub static trans_stats:             uint = 1 <<  4;
 pub static asm_comments:            uint = 1 <<  5;
 pub static no_verify:               uint = 1 <<  6;
-pub static trace:                   uint = 1 <<  7;
-pub static coherence:               uint = 1 <<  8;
-pub static borrowck_stats:          uint = 1 <<  9;
-pub static borrowck_note_pure:      uint = 1 << 10;
-pub static borrowck_note_loan:      uint = 1 << 11;
-pub static no_landing_pads:         uint = 1 << 12;
-pub static debug_llvm:              uint = 1 << 13;
-pub static count_type_sizes:        uint = 1 << 14;
-pub static meta_stats:              uint = 1 << 15;
-pub static no_opt:                  uint = 1 << 16;
-pub static gc:                      uint = 1 << 17;
-pub static jit:                     uint = 1 << 18;
-pub static debug_info:              uint = 1 << 19;
-pub static extra_debug_info:        uint = 1 << 20;
-pub static print_link_args:         uint = 1 << 21;
-pub static no_debug_borrows:        uint = 1 << 22;
-pub static lint_llvm:               uint = 1 << 23;
-pub static print_llvm_passes:       uint = 1 << 24;
-pub static no_vectorize_loops:      uint = 1 << 25;
-pub static no_vectorize_slp:        uint = 1 << 26;
-pub static no_prepopulate_passes:   uint = 1 << 27;
-pub static use_softfp:              uint = 1 << 28;
-pub static gen_crate_map:           uint = 1 << 29;
-pub static prefer_dynamic:          uint = 1 << 30;
+pub static coherence:               uint = 1 <<  7;
+pub static borrowck_stats:          uint = 1 <<  8;
+pub static borrowck_note_pure:      uint = 1 <<  9;
+pub static borrowck_note_loan:      uint = 1 << 10;
+pub static no_landing_pads:         uint = 1 << 11;
+pub static debug_llvm:              uint = 1 << 12;
+pub static count_type_sizes:        uint = 1 << 13;
+pub static meta_stats:              uint = 1 << 14;
+pub static no_opt:                  uint = 1 << 15;
+pub static gc:                      uint = 1 << 16;
+pub static debug_info:              uint = 1 << 17;
+pub static extra_debug_info:        uint = 1 << 18;
+pub static print_link_args:         uint = 1 << 19;
+pub static no_debug_borrows:        uint = 1 << 20;
+pub static lint_llvm:               uint = 1 << 21;
+pub static print_llvm_passes:       uint = 1 << 22;
+pub static no_vectorize_loops:      uint = 1 << 23;
+pub static no_vectorize_slp:        uint = 1 << 24;
+pub static no_prepopulate_passes:   uint = 1 << 25;
+pub static use_softfp:              uint = 1 << 26;
+pub static gen_crate_map:           uint = 1 << 27;
+pub static prefer_dynamic:          uint = 1 << 28;
 
 pub fn debugging_opts_map() -> ~[(&'static str, &'static str, uint)] {
     ~[("verbose", "in general, enable more debug printouts", verbose),
@@ -79,7 +77,6 @@ pub fn debugging_opts_map() -> ~[(&'static str, &'static str, uint)] {
      ("trans-stats", "gather trans statistics", trans_stats),
      ("asm-comments", "generate comments into the assembly (may change behavior)", asm_comments),
      ("no-verify", "skip LLVM verification", no_verify),
-     ("trace", "emit trace logs", trace),
      ("coherence", "perform coherence checking", coherence),
      ("borrowck-stats", "gather borrowck statistics",  borrowck_stats),
      ("borrowck-note-pure", "note where purity is req'd",
@@ -95,7 +92,6 @@ pub fn debugging_opts_map() -> ~[(&'static str, &'static str, uint)] {
      ("no-opt", "do not optimize, even if -O is passed", no_opt),
      ("print-link-args", "Print the arguments passed to the linker", print_link_args),
      ("gc", "Garbage collect shared data (experimental)", gc),
-     ("jit", "Execute using JIT (experimental)", jit),
      ("extra-debug-info", "Extra debugging info (experimental)",
       extra_debug_info),
      ("debug-info", "Produce debug info (experimental)", debug_info),
@@ -146,7 +142,6 @@ pub struct options {
     extra_debuginfo: bool,
     lint_opts: ~[(lint::lint, lint::level)],
     save_temps: bool,
-    jit: bool,
     output_type: back::link::output_type,
     addl_lib_search_paths: @mut HashSet<Path>, // This is mutable for rustpkg, which
                                                // updates search paths based on the
@@ -311,7 +306,6 @@ impl Session_ {
     pub fn asm_comments(&self) -> bool { self.debugging_opt(asm_comments) }
     pub fn no_verify(&self) -> bool { self.debugging_opt(no_verify) }
     pub fn lint_llvm(&self) -> bool { self.debugging_opt(lint_llvm) }
-    pub fn trace(&self) -> bool { self.debugging_opt(trace) }
     pub fn coherence(&self) -> bool { self.debugging_opt(coherence) }
     pub fn borrowck_stats(&self) -> bool { self.debugging_opt(borrowck_stats) }
     pub fn borrowck_note_pure(&self) -> bool {
@@ -370,7 +364,6 @@ pub fn basic_options() -> @options {
         extra_debuginfo: false,
         lint_opts: ~[],
         save_temps: false,
-        jit: false,
         output_type: link::output_type_exe,
         addl_lib_search_paths: @mut HashSet::new(),
         ar: None,

src/librustc/lib.rs

@@ -363,10 +363,6 @@ pub fn monitor(f: proc(@diagnostic::Emitter)) {
         let _finally = finally { ch: ch };
 
         f(demitter);
-
-        // Due reasons explain in #7732, if there was a jit execution context it
-        // must be consumed and passed along to our parent task.
-        back::link::jit::consume_engine()
     }) {
         result::Ok(_) => { /* fallthrough */ }
         result::Err(_) => {

src/librustc/lib/llvm.rs

@@ -1441,18 +1441,6 @@ pub mod llvm {
             call. */
         pub fn LLVMRustGetLastError() -> *c_char;
 
-        /** Prepare the JIT. Returns a memory manager that can load crates. */
-        pub fn LLVMRustPrepareJIT(__morestack: *()) -> *();
-
-        /** Load a crate into the memory manager. */
-        pub fn LLVMRustLoadCrate(MM: *(), Filename: *c_char) -> bool;
-
-        /** Execute the JIT engine. */
-        pub fn LLVMRustBuildJIT(MM: *(),
-                                M: ModuleRef,
-                                EnableSegmentedStacks: bool)
-                                -> ExecutionEngineRef;
-
         /// Print the pass timings since static dtors aren't picking them up.
         pub fn LLVMRustPrintPassTimings();