Remove C++ dependencies

mk/rt.mk

@@ -72,16 +72,16 @@ RUNTIME_CXXFLAGS_$(1)_$(2) = -D_RUST_STAGE1
 endif
 endif
 
-RUNTIME_CXXS_$(1)_$(2) := \
-	      rt/rust_cxx_glue.cpp
-
 RUNTIME_CS_$(1)_$(2) := \
               rt/rust_builtin.c \
               rt/rust_upcall.c \
               rt/miniz.c \
               rt/rust_android_dummy.c \
               rt/rust_test_helpers.c
 
+RUNTIME_LL_$(1)_$(2) := \
+			rt/rust_try.ll
+
 # stage0 remove this after the next snapshot
 %.cpp:
 	@touch tmp/foo.o
@@ -94,18 +94,17 @@ RT_BUILD_DIR_$(1)_$(2) := $$(RT_OUTPUT_DIR_$(1))/stage$(2)
 RUNTIME_DEF_$(1)_$(2) := $$(RT_OUTPUT_DIR_$(1))/rustrt$$(CFG_DEF_SUFFIX_$(1))
 RUNTIME_INCS_$(1)_$(2) := -I $$(S)src/rt -I $$(S)src/rt/isaac -I $$(S)src/rt/uthash \
                      -I $$(S)src/rt/arch/$$(HOST_$(1))
-RUNTIME_OBJS_$(1)_$(2) := $$(RUNTIME_CXXS_$(1)_$(2):rt/%.cpp=$$(RT_BUILD_DIR_$(1)_$(2))/%.o) \
+RUNTIME_OBJS_$(1)_$(2) := \
                      $$(RUNTIME_CS_$(1)_$(2):rt/%.c=$$(RT_BUILD_DIR_$(1)_$(2))/%.o) \
-                     $$(RUNTIME_S_$(1)_$(2):rt/%.S=$$(RT_BUILD_DIR_$(1)_$(2))/%.o)
+                     $$(RUNTIME_S_$(1)_$(2):rt/%.S=$$(RT_BUILD_DIR_$(1)_$(2))/%.o) \
+                     $$(RUNTIME_LL_$(1)_$(2):rt/%.ll=$$(RT_BUILD_DIR_$(1)_$(2))/%.o)
+
 ALL_OBJ_FILES += $$(RUNTIME_OBJS_$(1)_$(2))
 
 MORESTACK_OBJS_$(1)_$(2) := $$(RT_BUILD_DIR_$(1)_$(2))/arch/$$(HOST_$(1))/morestack.o
 ALL_OBJ_FILES += $$(MORESTACK_OBJS_$(1)_$(2))
 
-$$(RT_BUILD_DIR_$(1)_$(2))/rust_cxx_glue.o: rt/rust_cxx_glue.cpp $$(MKFILE_DEPS)
-	@$$(call E, compile: $$@)
-	$$(Q)$$(call CFG_COMPILE_CXX_$(1), $$@, $$(RUNTIME_INCS_$(1)_$(2)) \
-                 $$(SNAP_DEFINES) $$(RUNTIME_CXXFLAGS_$(1)_$(2))) $$<
+LLVM_LLC = $(CFG_LLVM_INST_DIR_$(CFG_BUILD))/bin/llc -filetype=obj -o $$1 $$2
 
 $$(RT_BUILD_DIR_$(1)_$(2))/%.o: rt/%.c $$(MKFILE_DEPS)
 	@$$(call E, compile: $$@)
@@ -117,6 +116,11 @@ $$(RT_BUILD_DIR_$(1)_$(2))/%.o: rt/%.S  $$(MKFILE_DEPS) \
 	@$$(call E, compile: $$@)
 	$$(Q)$$(call CFG_ASSEMBLE_$(1),$$@,$$<)
 
+$$(RT_BUILD_DIR_$(1)_$(2))/%.o: rt/%.ll  $$(MKFILE_DEPS) \
+                     $$(LLVM_CONFIG_$$(CFG_BUILD))
+	@$$(call E, compile: $$@)
+	$$(Q)$$(call LLVM_LLC,$$@,$$<)
+
 $$(RT_BUILD_DIR_$(1)_$(2))/arch/$$(HOST_$(1))/libmorestack.a: $$(MORESTACK_OBJS_$(1)_$(2))
 	@$$(call E, link: $$@)
 	$$(Q)$(AR_$(1)) rcs $$@ $$^

src/etc/mklldeps.py

@@ -59,6 +59,13 @@
     for lib in out.strip().split(' '):
         lib = lib[2:] # chop of the leading '-l'
         f.write("#[link(name = \"" + lib + "\", kind = \"static\")]\n")
+
+    # LLVM depends on C++ runtime, so we link it in (statically).
+    # Because our linker driver is gcc, not g++, it won't understand the -static-libstdc++ option,
+    # so we need to pass "-Bstatic -lstdc++ -Bdynamic" directly to ld.
+    f.write("#[link_args = \"-Xlinker -Bstatic -Xlinker -lstdc++ -Xlinker -Bdynamic\"]\n")
+
     if os == 'win32':
         f.write("#[link(name = \"imagehlp\")]\n")
+
     f.write("extern {}\n")

src/etc/snapshot.py

@@ -31,8 +31,7 @@ def scrub(b):
     "freebsd": ["bin/rustc"],
     }
 
-winnt_runtime_deps = ["libgcc_s_dw2-1.dll",
-                      "libstdc++-6.dll"]
+winnt_runtime_deps = ["libgcc_s_dw2-1.dll"]
 
 def parse_line(n, line):
   global snapshotfile

src/etc/third-party/README.txt

@@ -1,7 +1,7 @@
 Certain files in this distribution are covered by a different license than the rest of the Rust Project.
 Specifically:
 
-   - libgcc_s_dw2-1.dll and libstdc++6.dll are distributed under the terms of the GNU General Public License 
+   - libgcc_s_dw2-1.dll is distributed under the terms of the GNU General Public License 
      with the GCC Runtime Library Exception as published by the Free Software Foundation; either version 3, 
      or (at your option) any later version.  See the files COPYING3 and COPYING.RUNTIME respectively.
      You can obtain a copy of the source of these libraries either here: http://sourceforge.net/projects/mingw/files/MinGW/Base/gcc/Version4/gcc-4.5.2-1/,

src/librustc/back/link.rs

@@ -702,10 +702,7 @@ pub fn get_cc_prog(sess: Session) -> ~str {
     // In the future, FreeBSD will use clang as default compiler.
     // It would be flexible to use cc (system's default C compiler)
     // instead of hard-coded gcc.
-    // For win32, there is no cc command, so we add a condition to make it use
-    // g++.  We use g++ rather than gcc because it automatically adds linker
-    // options required for generation of dll modules that correctly register
-    // stack unwind tables.
+    // For win32, there is no cc command, so we add a condition to make it use gcc.
     match sess.targ_cfg.os {
         abi::OsAndroid => match sess.opts.android_cross_path {
             Some(ref path) => format!("{}/bin/arm-linux-androideabi-gcc", *path),
@@ -714,7 +711,7 @@ pub fn get_cc_prog(sess: Session) -> ~str {
                             (--android-cross-path)")
             }
         },
-        abi::OsWin32 => ~"g++",
+        abi::OsWin32 => ~"gcc",
         _ => ~"cc",
     }
 }
@@ -1023,6 +1020,12 @@ fn link_args(sess: Session,
         }
     }
 
+    if sess.targ_cfg.os == abi::OsWin32 {
+        // Make sure that we link to the dynamic libgcc, otherwise cross-module
+        // DWARF stack unwinding will not work.
+        args.push(~"-shared-libgcc");
+    }
+
     add_local_native_libraries(&mut args, sess);
     add_upstream_rust_crates(&mut args, sess, dylib, tmpdir);
     add_upstream_native_libraries(&mut args, sess);

src/librustc/lib.rs

@@ -16,7 +16,7 @@
 #[crate_type = "dylib"];
 #[crate_type = "rlib"];
 
-#[feature(macro_rules, globs, struct_variant, managed_boxes)];
+#[feature(macro_rules, globs, struct_variant, managed_boxes, link_args)];
 
 extern mod extra;
 extern mod syntax;
@@ -92,7 +92,6 @@ pub mod back {
     pub mod link;
     pub mod manifest;
     pub mod abi;
-    pub mod upcall;
     pub mod arm;
     pub mod mips;
     pub mod x86;

src/librustc/lib/llvm.rs

@@ -319,7 +319,6 @@ pub mod llvm {
     // automatically updated whenever LLVM is updated to include an up-to-date
     // set of the libraries we need to link to LLVM for.
     #[link(name = "rustllvm", kind = "static")]
-    #[link(name = "stdc++")]
     extern {
         /* Create and destroy contexts. */
         pub fn LLVMContextCreate() -> ContextRef;

src/librustc/middle/lang_items.rs

@@ -208,7 +208,7 @@ pub fn collect_language_items(crate: &ast::Crate,
 }
 
 lets_do_this! {
-    There are 42 lang items.
+    There are 43 lang items.
 
 //  ID, Variant name,                    Name,                      Method name;
     0,  FreezeTraitLangItem,             "freeze",                  freeze_trait;
@@ -261,5 +261,7 @@ lets_do_this! {
     40, EventLoopFactoryLangItem,        "event_loop_factory",      event_loop_factory;
 
     41, TypeIdLangItem,                  "type_id",                 type_id;
+
+    42, EhPersonalityLangItem,           "eh_personality",          eh_personality_fn;
 }
 

src/librustc/middle/trans/base.rs

@@ -37,6 +37,7 @@ use metadata::{csearch, cstore, encoder};
 use middle::astencode;
 use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem};
 use middle::lang_items::{MallocFnLangItem, ClosureExchangeMallocFnLangItem};
+use middle::lang_items::{EhPersonalityLangItem};
 use middle::trans::_match;
 use middle::trans::adt;
 use middle::trans::base;
@@ -1028,10 +1029,10 @@ pub fn get_landing_pad(bcx: @mut Block) -> BasicBlockRef {
     // this represents but it's determined by the personality function and
     // this is what the EH proposal example uses.
     let llretty = Type::struct_([Type::i8p(), Type::i32()], false);
-    // The exception handling personality function. This is the C++
-    // personality function __gxx_personality_v0, wrapped in our naming
-    // convention.
-    let personality = bcx.ccx().upcalls.rust_personality;
+    // The exception handling personality function.
+    let personality = callee::trans_fn_ref(bcx,
+                                           langcall(bcx, None, "", EhPersonalityLangItem),
+                                           0).llfn;
     // The only landing pad clause will be 'cleanup'
     let llretval = LandingPad(pad_bcx, llretty, personality, 1u);
     // The landing pad block is a cleanup
@@ -3197,6 +3198,7 @@ pub fn trans_crate(sess: session::Session,
     reachable.push(ccx.crate_map_name.to_owned());
     reachable.push(~"main");
     reachable.push(~"rust_stack_exhausted");
+    reachable.push(~"eh_rust_personality_catch"); // referenced from rt/rust_try.ll
 
     return CrateTranslation {
         context: llcx,

src/librustc/middle/trans/context.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 
-use back::{upcall};
 use driver::session;
 use lib::llvm::{ContextRef, ModuleRef, ValueRef};
 use lib::llvm::{llvm, TargetData, TypeNames};
@@ -105,7 +104,6 @@ pub struct CrateContext {
      tcx: ty::ctxt,
      maps: astencode::Maps,
      stats: @mut Stats,
-     upcalls: @upcall::Upcalls,
      tydesc_type: Type,
      int_type: Type,
      opaque_vec_type: Type,
@@ -233,7 +231,6 @@ impl CrateContext {
                     llvm_insns: HashMap::new(),
                     fn_stats: ~[]
                   },
-                  upcalls: upcall::declare_upcalls(targ_cfg, llmod),
                   tydesc_type: tydesc_type,
                   int_type: int_type,
                   opaque_vec_type: opaque_vec_type,

src/libstd/rt/mod.rs

@@ -173,6 +173,9 @@ mod local_ptr;
 /// Bindings to pthread/windows thread-local storage.
 mod thread_local_storage;
 
+/// Stack unwinding
+pub mod unwind;
+
 /// Just stuff
 mod util;
 

src/libstd/rt/task.rs

@@ -18,10 +18,9 @@ use super::local_heap::LocalHeap;
 use prelude::*;
 
 use borrow;
-use cast::transmute;
 use cleanup;
 use io::Writer;
-use libc::{c_void, uintptr_t, c_char, size_t};
+use libc::{c_char, size_t};
 use local_data;
 use option::{Option, Some, None};
 use rt::borrowck::BorrowRecord;
@@ -33,8 +32,8 @@ use rt::local::Local;
 use rt::logging::StdErrLogger;
 use rt::sched::{Scheduler, SchedHandle};
 use rt::stack::{StackSegment, StackPool};
+use rt::unwind::Unwinder;
 use send_str::SendStr;
-use task::TaskResult;
 use unstable::finally::Finally;
 use unstable::mutex::Mutex;
 
@@ -91,21 +90,6 @@ pub enum SchedHome {
 pub struct GarbageCollector;
 pub struct LocalStorage(Option<local_data::Map>);
 
-pub struct Unwinder {
-    unwinding: bool,
-    cause: Option<~Any>
-}
-
-impl Unwinder {
-    fn result(&mut self) -> TaskResult {
-        if self.unwinding {
-            Err(self.cause.take().unwrap())
-        } else {
-            Ok(())
-        }
-    }
-}
-
 impl Task {
 
     // A helper to build a new task using the dynamically found
@@ -452,54 +436,6 @@ impl Coroutine {
 
 }
 
-
-// Just a sanity check to make sure we are catching a Rust-thrown exception
-static UNWIND_TOKEN: uintptr_t = 839147;
-
-impl Unwinder {
-    pub fn try(&mut self, f: ||) {
-        use unstable::raw::Closure;
-
-        unsafe {
-            let closure: Closure = transmute(f);
-            let code = transmute(closure.code);
-            let env = transmute(closure.env);
-
-            let token = rust_try(try_fn, code, env);
-            assert!(token == 0 || token == UNWIND_TOKEN);
-        }
-
-        extern fn try_fn(code: *c_void, env: *c_void) {
-            unsafe {
-                let closure: Closure = Closure {
-                    code: transmute(code),
-                    env: transmute(env),
-                };
-                let closure: || = transmute(closure);
-                closure();
-            }
-        }
-
-        extern {
-            fn rust_try(f: extern "C" fn(*c_void, *c_void),
-                        code: *c_void,
-                        data: *c_void) -> uintptr_t;
-        }
-    }
-
-    pub fn begin_unwind(&mut self, cause: ~Any) -> ! {
-        self.unwinding = true;
-        self.cause = Some(cause);
-        unsafe {
-            rust_begin_unwind(UNWIND_TOKEN);
-            return transmute(());
-        }
-        extern {
-            fn rust_begin_unwind(token: uintptr_t);
-        }
-    }
-}
-
 /// This function is invoked from rust's current __morestack function. Segmented
 /// stacks are currently not enabled as segmented stacks, but rather one giant
 /// stack segment. This means that whenever we run out of stack, we want to