rustc: remove old bitrotted gc system.

Author: graydon

src/librustc/driver/driver.rs

@@ -124,10 +124,6 @@ pub fn build_configuration(sess: Session, argv0: @~str, input: &input) ->
     // If the user wants a test runner, then add the test cfg
     let user_cfg = if sess.opts.test { append_configuration(user_cfg, ~"test") }
                    else { user_cfg };
-    // If the user requested GC, then add the GC cfg
-    let user_cfg = append_configuration(
-        user_cfg,
-        if sess.opts.gc { ~"gc" } else { ~"nogc" });
     return vec::append(user_cfg, default_cfg);
 }
 
@@ -651,7 +647,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 ||
@@ -697,7 +692,6 @@ pub fn build_session_options(binary: @~str,
     let sopts = @session::options {
         crate_type: crate_type,
         is_static: statik,
-        gc: gc,
         optimize: opt_level,
         custom_passes: custom_passes,
         debuginfo: debuginfo,

src/librustc/driver/session.rs

@@ -62,7 +62,6 @@ pub static count_type_sizes: uint = 1 << 14;
 pub static meta_stats: uint = 1 << 15;
 pub static no_opt: uint = 1 << 16;
 pub static no_monomorphic_collapse: uint = 1 << 17;
-pub static gc: uint = 1 << 18;
 pub static jit: uint = 1 << 19;
 pub static debug_info: uint = 1 << 20;
 pub static extra_debug_info: uint = 1 << 21;
@@ -98,7 +97,6 @@ pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
      (~"no-monomorphic-collapse", ~"do not collapse template instantiations",
       no_monomorphic_collapse),
      (~"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),
@@ -127,7 +125,6 @@ pub struct options {
     // with additional crate configurations during the compile process
     crate_type: crate_type,
     is_static: bool,
-    gc: bool,
     optimize: OptLevel,
     custom_passes: ~[~str],
     debuginfo: bool,
@@ -303,7 +300,6 @@ pub fn basic_options() -> @options {
     @options {
         crate_type: session::lib_crate,
         is_static: false,
-        gc: false,
         optimize: No,
         custom_passes: ~[],
         debuginfo: false,

src/librustc/middle/trans/_match.rs

@@ -1387,19 +1387,17 @@ pub fn compile_submatch(bcx: block,
     if any_box_pat(m, col) {
         bcx = root_pats_as_necessary(bcx, m, col, val);
         let llbox = Load(bcx, val);
-        let box_no_addrspace = non_gc_box_cast(bcx, llbox);
         let unboxed =
-            GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
+            GEPi(bcx, llbox, [0u, abi::box_field_body]);
         compile_submatch(bcx, enter_box(bcx, dm, m, col, val),
                          vec::append(~[unboxed], vals_left), chk);
         return;
     }
 
     if any_uniq_pat(m, col) {
         let llbox = Load(bcx, val);
-        let box_no_addrspace = non_gc_box_cast(bcx, llbox);
         let unboxed =
-            GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
+            GEPi(bcx, llbox, [0u, abi::box_field_body]);
         compile_submatch(bcx, enter_uniq(bcx, dm, m, col, val),
                          vec::append(~[unboxed], vals_left), chk);
         return;

src/librustc/middle/trans/base.rs

@@ -310,25 +310,6 @@ pub fn malloc_raw_dyn(bcx: block,
     r
 }
 
-/**
-* Get the type of a box in the default address space.
-*
-* Shared box pointers live in address space 1 so the GC strategy can find
-* them. Before taking a pointer to the inside of a box it should be cast into
-* address space 0. Otherwise the resulting (non-box) pointer will be in the
-* wrong address space and thus be the wrong type.
-*/
-pub fn non_gc_box_cast(bcx: block, val: ValueRef) -> ValueRef {
-    unsafe {
-        debug!("non_gc_box_cast");
-        add_comment(bcx, "non_gc_box_cast");
-        assert!(llvm::LLVMGetPointerAddressSpace(val_ty(val)) ==
-                     gc_box_addrspace || bcx.unreachable);
-        let non_gc_t = T_ptr(llvm::LLVMGetElementType(val_ty(val)));
-        PointerCast(bcx, val, non_gc_t)
-    }
-}
-
 // malloc_raw: expects an unboxed type and returns a pointer to
 // enough space for a box of that type.  This includes a rust_opaque_box
 // header.
@@ -348,8 +329,7 @@ pub fn malloc_general_dyn(bcx: block, t: ty::t, heap: heap, size: ValueRef)
     -> MallocResult {
     let _icx = bcx.insn_ctxt("malloc_general");
     let Result {bcx: bcx, val: llbox} = malloc_raw_dyn(bcx, t, heap, size);
-    let non_gc_box = non_gc_box_cast(bcx, llbox);
-    let body = GEPi(bcx, non_gc_box, [0u, abi::box_field_body]);
+    let body = GEPi(bcx, llbox, [0u, abi::box_field_body]);
 
     MallocResult { bcx: bcx, box: llbox, body: body }
 }
@@ -1853,16 +1833,6 @@ pub fn trans_closure(ccx: @CrateContext,
         set_fixed_stack_segment(fcx.llfn);
     }
 
-    // Set GC for function.
-    if ccx.sess.opts.gc {
-        do str::as_c_str("generic") |strategy| {
-            unsafe {
-                llvm::LLVMSetGC(fcx.llfn, strategy);
-            }
-        }
-        *ccx.uses_gc = true;
-    }
-
     // Create the first basic block in the function and keep a handle on it to
     //  pass to finish_fn later.
     let bcx_top = top_scope_block(fcx, body.info());
@@ -2654,14 +2624,7 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> {
         ~[T_ptr(T_i8()), T_i8(), T_i64(), T_i32(), T_i1()];
     let T_trap_args: ~[TypeRef] = ~[];
     let T_frameaddress_args: ~[TypeRef] = ~[T_i32()];
-    let gcroot =
-        decl_cdecl_fn(llmod, "llvm.gcroot",
-                      T_fn([T_ptr(T_ptr(T_i8())), T_ptr(T_i8())],
-                           T_void()));
-    let gcread =
-        decl_cdecl_fn(llmod, "llvm.gcread",
-                      T_fn([T_ptr(T_i8()), T_ptr(T_ptr(T_i8()))],
-                           T_void()));
+
     let memcpy32 =
         decl_cdecl_fn(llmod, "llvm.memcpy.p0i8.p0i8.i32",
                       T_fn(copy T_memcpy32_args, T_void()));
@@ -2777,8 +2740,6 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<~str, ValueRef> {
                                 T_fn([T_i64()], T_i64()));
 
     let mut intrinsics = HashMap::new();
-    intrinsics.insert(~"llvm.gcroot", gcroot);
-    intrinsics.insert(~"llvm.gcread", gcread);
     intrinsics.insert(~"llvm.memcpy.p0i8.p0i8.i32", memcpy32);
     intrinsics.insert(~"llvm.memcpy.p0i8.p0i8.i64", memcpy64);
     intrinsics.insert(~"llvm.memmove.p0i8.p0i8.i32", memmove32);
@@ -2856,24 +2817,6 @@ pub fn trap(bcx: block) {
     }
 }
 
-pub fn decl_gc_metadata(ccx: @CrateContext, llmod_id: &str) {
-    if !ccx.sess.opts.gc || !*ccx.uses_gc {
-        return;
-    }
-
-    let gc_metadata_name = ~"_gc_module_metadata_" + llmod_id;
-    let gc_metadata = do str::as_c_str(gc_metadata_name) |buf| {
-        unsafe {
-            llvm::LLVMAddGlobal(ccx.llmod, T_i32(), buf)
-        }
-    };
-    unsafe {
-        llvm::LLVMSetGlobalConstant(gc_metadata, True);
-        lib::llvm::SetLinkage(gc_metadata, lib::llvm::ExternalLinkage);
-        ccx.module_data.insert(~"_gc_module_metadata", gc_metadata);
-    }
-}
-
 pub fn create_module_map(ccx: @CrateContext) -> ValueRef {
     let elttype = T_struct([ccx.int_type, ccx.int_type], false);
     let maptype = T_array(elttype, ccx.module_data.len() + 1);
@@ -3103,7 +3046,6 @@ pub fn trans_crate(sess: session::Session,
               llsizingtypes: @mut HashMap::new(),
               adt_reprs: @mut HashMap::new(),
               names: new_namegen(sess.parse_sess.interner),
-              next_addrspace: new_addrspace_gen(),
               symbol_hasher: symbol_hasher,
               type_hashcodes: @mut HashMap::new(),
               type_short_names: @mut HashMap::new(),
@@ -3131,7 +3073,6 @@ pub fn trans_crate(sess: session::Session,
               builder: BuilderRef_res(unsafe { llvm::LLVMCreateBuilder() }),
               shape_cx: mk_ctxt(llmod),
               crate_map: crate_map,
-              uses_gc: @mut false,
               dbg_cx: dbg_cx,
               do_not_commit_warning_issued: @mut false
         };
@@ -3146,7 +3087,6 @@ pub fn trans_crate(sess: session::Session,
             trans_mod(ccx, &crate.node.module);
         }
 
-        decl_gc_metadata(ccx, llmod_id);
         fill_crate_map(ccx, crate_map);
         glue::emit_tydescs(ccx);
         write_abi_version(ccx);

src/librustc/middle/trans/common.rs

@@ -66,29 +66,18 @@ pub fn new_namegen(intr: @ident_interner) -> namegen {
     f
 }
 
-pub type addrspace = c_uint;
 
-// Address spaces communicate to LLVM which destructors need to run for
-// specific types.
-//    0 is ignored by the GC, and is used for all non-GC'd pointers.
-//    1 is for opaque GC'd boxes.
-//    >= 2 are for specific types (e.g. resources).
+// Multiple address spaces were at one time used to encode
+// GC information. They may be again someday. In the meantime
+// we only support a single addrspace.
+pub type addrspace = c_uint;
 pub static default_addrspace: addrspace = 0;
-pub static gc_box_addrspace: addrspace = 1;
-
-pub type addrspace_gen = @fn() -> addrspace;
-pub fn new_addrspace_gen() -> addrspace_gen {
-    let i = @mut 1;
-    let result: addrspace_gen = || { *i += 1; *i };
-    result
-}
 
 pub struct tydesc_info {
     ty: ty::t,
     tydesc: ValueRef,
     size: ValueRef,
     align: ValueRef,
-    addrspace: addrspace,
     take_glue: Option<ValueRef>,
     drop_glue: Option<ValueRef>,
     free_glue: Option<ValueRef>,
@@ -208,7 +197,6 @@ pub struct CrateContext {
      llsizingtypes: @mut HashMap<ty::t, TypeRef>,
      adt_reprs: @mut HashMap<ty::t, @adt::Repr>,
      names: namegen,
-     next_addrspace: addrspace_gen,
      symbol_hasher: @mut hash::State,
      type_hashcodes: @mut HashMap<ty::t, @str>,
      type_short_names: @mut HashMap<ty::t, ~str>,
@@ -224,10 +212,6 @@ pub struct CrateContext {
      builder: BuilderRef_res,
      shape_cx: shape::Ctxt,
      crate_map: ValueRef,
-     // Set when at least one function uses GC. Needed so that
-     // decl_gc_metadata knows whether to link to the module metadata, which
-     // is not emitted by LLVM's GC pass when no functions use GC.
-     uses_gc: @mut bool,
      dbg_cx: Option<debuginfo::DebugContext>,
      do_not_commit_warning_issued: @mut bool
 }
@@ -426,38 +410,16 @@ pub fn cleanup_type(cx: ty::ctxt, ty: ty::t) -> cleantype {
     }
 }
 
-// This is not the same as datum::Datum::root(), which is used to keep copies
-// of @ values live for as long as a borrowed pointer to the interior exists.
-// In the new GC, we can identify immediates on the stack without difficulty,
-// but have trouble knowing where non-immediates are on the stack. For
-// non-immediates, we must add an additional level of indirection, which
-// allows us to alloca a pointer with the right addrspace.
-pub fn root_for_cleanup(bcx: block, v: ValueRef, t: ty::t)
-    -> (ValueRef, bool) {
-    let ccx = bcx.ccx();
-
-    let addrspace = base::get_tydesc(ccx, t).addrspace;
-    if addrspace > gc_box_addrspace {
-        let llty = type_of::type_of_rooted(ccx, t);
-        let root = base::alloca(bcx, llty);
-        build::Store(bcx, build::PointerCast(bcx, v, llty), root);
-        (root, true)
-    } else {
-        (v, false)
-    }
-}
-
 pub fn add_clean(bcx: block, val: ValueRef, t: ty::t) {
     if !ty::type_needs_drop(bcx.tcx(), t) { return; }
     debug!("add_clean(%s, %s, %s)",
            bcx.to_str(),
            val_str(bcx.ccx().tn, val),
            t.repr(bcx.tcx()));
-    let (root, rooted) = root_for_cleanup(bcx, val, t);
     let cleanup_type = cleanup_type(bcx.tcx(), t);
     do in_scope_cx(bcx) |scope_info| {
         scope_info.cleanups.push(
-            clean(|a| glue::drop_ty_root(a, root, rooted, t),
+            clean(|a| glue::drop_ty(a, val, t),
                   cleanup_type));
         scope_clean_changed(scope_info);
     }
@@ -481,11 +443,10 @@ pub fn add_clean_temp_mem(bcx: block, val: ValueRef, t: ty::t) {
     debug!("add_clean_temp_mem(%s, %s, %s)",
            bcx.to_str(), val_str(bcx.ccx().tn, val),
            t.repr(bcx.tcx()));
-    let (root, rooted) = root_for_cleanup(bcx, val, t);
     let cleanup_type = cleanup_type(bcx.tcx(), t);
     do in_scope_cx(bcx) |scope_info| {
         scope_info.cleanups.push(
-            clean_temp(val, |a| glue::drop_ty_root(a, root, rooted, t),
+            clean_temp(val, |a| glue::drop_ty(a, val, t),
                        cleanup_type));
         scope_clean_changed(scope_info);
     }
@@ -895,12 +856,6 @@ pub fn T_ptr(t: TypeRef) -> TypeRef {
     }
 }
 
-pub fn T_root(t: TypeRef, addrspace: addrspace) -> TypeRef {
-    unsafe {
-        return llvm::LLVMPointerType(t, addrspace);
-    }
-}
-
 pub fn T_struct(elts: &[TypeRef], packed: bool) -> TypeRef {
     unsafe {
         return llvm::LLVMStructType(to_ptr(elts),
@@ -1054,7 +1009,7 @@ pub fn T_box(cx: @CrateContext, t: TypeRef) -> TypeRef {
 
 pub fn T_box_ptr(t: TypeRef) -> TypeRef {
     unsafe {
-        return llvm::LLVMPointerType(t, gc_box_addrspace);
+        return llvm::LLVMPointerType(t, default_addrspace);
     }
 }
 
@@ -1072,7 +1027,7 @@ pub fn T_unique(cx: @CrateContext, t: TypeRef) -> TypeRef {
 
 pub fn T_unique_ptr(t: TypeRef) -> TypeRef {
     unsafe {
-        return llvm::LLVMPointerType(t, gc_box_addrspace);
+        return llvm::LLVMPointerType(t, default_addrspace);
     }
 }