Remove experimental GC code

It's been sitting unused long enough to have bitrotted completely.

8 files changed, 8 insertions, 172 deletions

diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs
index c78e329e66b..e3a124640e4 100644
--- a/src/comp/back/upcall.rs
+++ b/src/comp/back/upcall.rs
@@ -56,7 +56,7 @@ fn declare_upcalls(targ_cfg: @session::config,
               d("malloc", [T_ptr(tydesc_type)],
                 T_ptr(T_i8())),
           free:
-              dv("free", [T_ptr(T_i8()), int_t]),
+              dv("free", [T_ptr(T_i8())]),
           validate_box:
               dv("validate_box", [T_ptr(T_i8())]),
           shared_malloc:
diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs
index 3a96762f41e..3f39ba1d123 100644
--- a/src/comp/driver/driver.rs
+++ b/src/comp/driver/driver.rs
@@ -412,7 +412,6 @@ fn build_session_options(match: getopts::match,
     let addl_lib_search_paths = getopts::opt_strs(match, "L");
     let cfg = parse_cfgspecs(getopts::opt_strs(match, "cfg"));
     let test = opt_present(match, "test");
-    let do_gc = opt_present(match, "gc");
     let warn_unused_imports = opt_present(match, "warn-unused-imports");
     let sopts: @session::options =
         @{crate_type: crate_type,
@@ -434,7 +433,6 @@ fn build_session_options(match: getopts::match,
           test: test,
           parse_only: parse_only,
           no_trans: no_trans,
-          do_gc: do_gc,
           no_asm_comments: no_asm_comments,
           warn_unused_imports: warn_unused_imports};
     ret sopts;
diff --git a/src/comp/driver/session.rs b/src/comp/driver/session.rs
index 897e367251c..30e7aec4374 100644
--- a/src/comp/driver/session.rs
+++ b/src/comp/driver/session.rs
@@ -46,7 +46,6 @@ type options =
      test: bool,
      parse_only: bool,
      no_trans: bool,
-     do_gc: bool,
      no_asm_comments: bool,
      warn_unused_imports: bool};
 
diff --git a/src/comp/middle/gc.rs b/src/comp/middle/gc.rs
deleted file mode 100644
index 0fe72c5b8f7..00000000000
--- a/src/comp/middle/gc.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-// Routines useful for garbage collection.
-
-import lib::llvm::{True, ValueRef};
-import trans::base::get_tydesc;
-import trans::common::*;
-import trans::base;
-import option::none;
-import str;
-import driver::session::session;
-
-import lll = lib::llvm::llvm;
-import bld = trans::build;
-
-type ctxt = @{mutable next_tydesc_num: uint};
-
-fn mk_ctxt() -> ctxt { ret @{mutable next_tydesc_num: 0u}; }
-
-fn add_global(ccx: @crate_ctxt, llval: ValueRef, name: str) -> ValueRef {
-    let llglobal =
-        str::as_buf(name,
-                    {|buf|
-                        lll::LLVMAddGlobal(ccx.llmod, val_ty(llval), buf)
-                    });
-    lll::LLVMSetInitializer(llglobal, llval);
-    lll::LLVMSetGlobalConstant(llglobal, True);
-    ret llglobal;
-}
-
-fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt {
-    let bcx = cx;
-    let ccx = bcx_ccx(cx);
-    if !type_is_gc_relevant(bcx_tcx(cx), ty) ||
-           ty::type_has_dynamic_size(bcx_tcx(cx), ty) {
-        ret bcx;
-    }
-
-    let gc_cx = bcx_ccx(cx).gc_cx;
-
-    // FIXME (issue #839): For now, we are unconditionally zeroing out all
-    // GC-relevant types. Eventually we should use typestate for this.
-    bcx = base::zero_alloca(bcx, llval, ty);
-
-    let ti = none;
-    let td_r = get_tydesc(bcx, ty, false, ti);
-    bcx = td_r.result.bcx;
-    let lltydesc = td_r.result.val;
-
-    let gcroot = bcx_ccx(bcx).intrinsics.get("llvm.gcroot");
-    let llvalptr = bld::PointerCast(bcx, llval, T_ptr(T_ptr(T_i8())));
-
-    alt td_r.kind {
-      tk_derived {
-        // It's a derived type descriptor. First, spill it.
-        let lltydescptr = base::alloca(bcx, val_ty(lltydesc));
-
-        let llderivedtydescs =
-            base::llderivedtydescs_block_ctxt(bcx_fcx(bcx));
-        bld::Store(llderivedtydescs, lltydesc, lltydescptr);
-
-        let number = gc_cx.next_tydesc_num;
-        gc_cx.next_tydesc_num += 1u;
-
-        let lldestindex =
-            add_global(bcx_ccx(bcx), C_struct([C_int(ccx, 0),
-                                               C_uint(ccx, number)]),
-                       "rust_gc_tydesc_dest_index");
-        let llsrcindex =
-            add_global(bcx_ccx(bcx), C_struct([C_int(ccx, 1),
-                                               C_uint(ccx, number)]),
-                       "rust_gc_tydesc_src_index");
-
-        lldestindex = lll::LLVMConstPointerCast(lldestindex, T_ptr(T_i8()));
-        llsrcindex = lll::LLVMConstPointerCast(llsrcindex, T_ptr(T_i8()));
-
-        lltydescptr =
-            bld::PointerCast(llderivedtydescs, lltydescptr,
-                             T_ptr(T_ptr(T_i8())));
-
-        bld::Call(llderivedtydescs, gcroot, [lltydescptr, lldestindex]);
-        bld::Call(bcx, gcroot, [llvalptr, llsrcindex]);
-      }
-      tk_param {
-        bcx_tcx(cx).sess.bug("we should never be trying to root values " +
-                                 "of a type parameter");
-      }
-      tk_static {
-        // Static type descriptor.
-
-        let llstaticgcmeta =
-            add_global(bcx_ccx(bcx), C_struct([C_int(ccx, 2), lltydesc]),
-                       "rust_gc_tydesc_static_gc_meta");
-        let llstaticgcmetaptr =
-            lll::LLVMConstPointerCast(llstaticgcmeta, T_ptr(T_i8()));
-
-        bld::Call(bcx, gcroot, [llvalptr, llstaticgcmetaptr]);
-      }
-    }
-
-    ret bcx;
-}
-
-fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool {
-    alt ty::struct(cx, ty) {
-      ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_int(_) |
-      ty::ty_float(_) | ty::ty_uint(_) | ty::ty_str |
-      ty::ty_type | ty::ty_send_type | ty::ty_ptr(_) {
-        ret false;
-      }
-      ty::ty_rec(fields) {
-        for f in fields { if type_is_gc_relevant(cx, f.mt.ty) { ret true; } }
-        ret false;
-      }
-      ty::ty_tup(elts) {
-        for elt in elts { if type_is_gc_relevant(cx, elt) { ret true; } }
-        ret false;
-      }
-      ty::ty_enum(did, tps) {
-        let variants = ty::enum_variants(cx, did);
-        for variant in *variants {
-            for aty in variant.args {
-                let arg_ty = ty::substitute_type_params(cx, tps, aty);
-                if type_is_gc_relevant(cx, arg_ty) { ret true; }
-            }
-        }
-        ret false;
-      }
-      ty::ty_vec(tm) {
-        ret type_is_gc_relevant(cx, tm.ty);
-      }
-      ty::ty_constr(sub, _) { ret type_is_gc_relevant(cx, sub); }
-      ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_fn(_) |
-      ty::ty_param(_, _) | ty::ty_res(_, _, _) { ret true; }
-      ty::ty_opaque_closure_ptr(_) {
-        ret false; // I guess?
-      }
-      // A precondition to rule out these cases would be nice
-      ty::ty_var(_) {
-        fail "ty_var in type_is_gc_relevant";
-      }
-      ty::ty_iface(_, _) {
-        fail "ty_iface in type_is_gc_relevant";
-      }
-      ty::ty_named(_,_) {
-        fail "ty_named in type_is_gc_relevant";
-      }
-    }
-}
-
diff --git a/src/comp/middle/trans/base.rs b/src/comp/middle/trans/base.rs
index 461aea91a94..76493e767dc 100644
--- a/src/comp/middle/trans/base.rs
+++ b/src/comp/middle/trans/base.rs
@@ -21,7 +21,6 @@ import option::{some, none};
 import driver::session;
 import session::session;
 import front::attr;
-import middle::{ty, gc, resolve, debuginfo};
 import middle::freevars::*;
 import back::{link, abi, upcall};
 import syntax::{ast, ast_util, codemap};
@@ -350,14 +349,9 @@ fn trans_native_call(cx: @block_ctxt, externs: hashmap<str, ValueRef>,
     ret Call(cx, llnative, call_args);
 }
 
-fn trans_free_if_not_gc(cx: @block_ctxt, v: ValueRef) -> @block_ctxt {
-    let ccx = bcx_ccx(cx);
-    if !ccx.sess.opts.do_gc {
-        Call(cx, ccx.upcalls.free,
-             [PointerCast(cx, v, T_ptr(T_i8())),
-              C_int(bcx_ccx(cx), 0)]);
-    }
-    ret cx;
+fn trans_free(cx: @block_ctxt, v: ValueRef) -> @block_ctxt {
+    Call(cx, bcx_ccx(cx).upcalls.free, [PointerCast(cx, v, T_ptr(T_i8()))]);
+    cx
 }
 
 fn trans_shared_free(cx: @block_ctxt, v: ValueRef) -> @block_ctxt {
@@ -1245,7 +1239,7 @@ fn free_box(bcx: @block_ctxt, v: ValueRef, t: ty::t) -> @block_ctxt {
         let v = PointerCast(bcx, v, type_of_1(bcx, t));
         let body = GEPi(bcx, v, [0, abi::box_field_body]);
         let bcx = drop_ty(bcx, body, body_mt.ty);
-        trans_free_if_not_gc(bcx, v)
+        trans_free(bcx, v)
       }
 
       _ { fail "free_box invoked with non-box type"; }
@@ -1280,7 +1274,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) {
         let ti = none;
         call_tydesc_glue_full(bcx, body, tydesc,
                               abi::tydesc_field_drop_glue, ti);
-        trans_free_if_not_gc(bcx, b)
+        trans_free(bcx, b)
       }
       ty::ty_send_type {
         // sendable type descriptors are basically unique pointers,
@@ -4226,10 +4220,6 @@ fn alloc_ty(cx: @block_ctxt, t: ty::t) -> result {
     // past caller conventions and may well make sense again,
     // so we leave it as-is.
 
-    if bcx_tcx(cx).sess.opts.do_gc {
-        bcx = gc::add_gc_root(bcx, val, t);
-    }
-
     ret rslt(cx, val);
 }
 
@@ -5604,7 +5594,6 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           opaque_vec_type: T_opaque_vec(targ_cfg),
           builder: BuilderRef_res(llvm::LLVMCreateBuilder()),
           shape_cx: shape::mk_ctxt(llmod),
-          gc_cx: gc::mk_ctxt(),
           crate_map: crate_map,
           dbg_cx: dbg_cx,
           mutable do_not_commit_warning_issued: false};
diff --git a/src/comp/middle/trans/closure.rs b/src/comp/middle/trans/closure.rs
index ad2c9e1d309..d051662a14e 100644
--- a/src/comp/middle/trans/closure.rs
+++ b/src/comp/middle/trans/closure.rs
@@ -716,7 +716,7 @@ fn make_opaque_cbox_free_glue(
         alt ck {
           ty::ck_block { fail "Impossible"; }
           ty::ck_box {
-            trans_free_if_not_gc(bcx, cbox)
+            trans_free(bcx, cbox)
           }
           ty::ck_uniq {
             let bcx = free_ty(bcx, tydesc, mk_tydesc_ty(tcx, ck));
diff --git a/src/comp/middle/trans/common.rs b/src/comp/middle/trans/common.rs
index 2670571aa6e..20f32954438 100644
--- a/src/comp/middle/trans/common.rs
+++ b/src/comp/middle/trans/common.rs
@@ -120,7 +120,6 @@ type crate_ctxt =
      opaque_vec_type: TypeRef,
      builder: BuilderRef_res,
      shape_cx: shape::ctxt,
-     gc_cx: gc::ctxt,
      crate_map: ValueRef,
      dbg_cx: option<@debuginfo::debug_ctxt>,
      mutable do_not_commit_warning_issued: bool};
@@ -286,7 +285,7 @@ fn add_clean_temp_mem(cx: @block_ctxt, val: ValueRef, ty: ty::t) {
 fn add_clean_free(cx: @block_ctxt, ptr: ValueRef, shared: bool) {
     let scope_cx = find_scope_cx(cx);
     let free_fn = if shared { bind base::trans_shared_free(_, ptr) }
-                  else { bind base::trans_free_if_not_gc(_, ptr) };
+                  else { bind base::trans_free(_, ptr) };
     scope_cx.cleanups += [clean_temp(ptr, free_fn)];
     scope_cx.lpad_dirty = true;
 }
diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc
index f655054ab1f..6f63bb36933 100644
--- a/src/comp/rustc.rc
+++ b/src/comp/rustc.rc
@@ -39,7 +39,6 @@ mod middle {
     mod kind;
     mod freevars;
     mod shape;
-    mod gc;
     mod debuginfo;
     mod capture;
     mod pat_util;