From 6323a012bd1417451cd81f00679039d630dc1695 Mon Sep 17 00:00:00 2001 From: Marijn Haverbeke Date: Thu, 20 Oct 2011 11:42:40 +0200 Subject: [PATCH] Remove taskptr argument from upcalls Issue #466 --- src/comp/back/upcall.rs | 38 ++++++++++++++---------------------- src/comp/middle/trans.rs | 32 +++++++++++++----------------- src/comp/middle/trans_vec.rs | 5 ++--- src/rt/rust_shape.cpp | 4 ++-- src/rt/rust_upcall.cpp | 38 ++++++++++++++++++++---------------- 5 files changed, 54 insertions(+), 63 deletions(-) diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs index 71509e128008..693212bfb892 100644 --- a/src/comp/back/upcall.rs +++ b/src/comp/back/upcall.rs @@ -39,13 +39,8 @@ fn declare_upcalls(_tn: type_names, tydesc_type: TypeRef, let fn_ty = T_fn(arg_tys, rv); ret trans::decl_cdecl_fn(llmod, "upcall_" + name, fn_ty); } - fn decl_with_taskptr(taskptr_type: TypeRef, llmod: ModuleRef, name: str, - tys: [TypeRef], rv: TypeRef) -> ValueRef { - ret decl(llmod, name, [taskptr_type] + tys, rv); - } - let dv = bind decl_with_taskptr(taskptr_type, llmod, _, _, T_void()); - let d = bind decl_with_taskptr(taskptr_type, llmod, _, _, _); - let dr = bind decl(llmod, _, _, _); + let d = bind decl(llmod, _, _, _); + let dv = bind decl(llmod, _, _, T_void()); ret @{_fail: dv("fail", [T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]), malloc: @@ -61,31 +56,28 @@ fn declare_upcalls(_tn: type_names, tydesc_type: TypeRef, [T_ptr(T_nil()), T_size_t(), T_size_t(), T_size_t(), T_ptr(T_ptr(tydesc_type)), T_int()], T_ptr(tydesc_type)), vec_grow: - d("vec_grow", [T_ptr(T_ptr(T_opaque_vec())), T_int()], - T_void()), + dv("vec_grow", [T_ptr(T_ptr(T_opaque_vec())), T_int()]), vec_push: - d("vec_push", - [T_ptr(T_ptr(T_opaque_vec())), T_ptr(tydesc_type), - T_ptr(T_i8())], T_void()), + dv("vec_push", + [T_ptr(T_ptr(T_opaque_vec())), T_ptr(tydesc_type), + T_ptr(T_i8())]), cmp_type: - dr("cmp_type", + dv("cmp_type", [T_ptr(T_i1()), taskptr_type, T_ptr(tydesc_type), T_ptr(T_ptr(tydesc_type)), T_ptr(T_i8()), T_ptr(T_i8()), - T_i8()], T_void()), + T_i8()]), log_type: - dr("log_type", - [taskptr_type, T_ptr(tydesc_type), T_ptr(T_i8()), T_i32()], - T_void()), + dv("log_type", [T_ptr(tydesc_type), T_ptr(T_i8()), T_i32()]), dynastack_mark: d("dynastack_mark", [], T_ptr(T_i8())), dynastack_alloc: d("dynastack_alloc_2", [T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())), - dynastack_free: d("dynastack_free", [T_ptr(T_i8())], T_void()), - alloc_c_stack: dr("alloc_c_stack", [T_size_t()], T_ptr(T_i8())), - call_c_stack: dr("call_c_stack", - [T_ptr(T_fn([], T_int())), T_ptr(T_i8())], - T_int()), - rust_personality: dr("rust_personality", [], T_i32()) + dynastack_free: dv("dynastack_free", [T_ptr(T_i8())]), + alloc_c_stack: d("alloc_c_stack", [T_size_t()], T_ptr(T_i8())), + call_c_stack: d("call_c_stack", + [T_ptr(T_fn([], T_int())), T_ptr(T_i8())], + T_int()), + rust_personality: d("rust_personality", [], T_i32()) }; } // diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index e750b79fda66..2e63306ee01e 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -389,13 +389,13 @@ fn trans_native_call(cx: @block_ctxt, externs: hashmap, fn trans_non_gc_free(cx: @block_ctxt, v: ValueRef) -> @block_ctxt { Call(cx, bcx_ccx(cx).upcalls.free, - [cx.fcx.lltaskptr, PointerCast(cx, v, T_ptr(T_i8())), C_int(0)]); + [PointerCast(cx, v, T_ptr(T_i8())), C_int(0)]); ret cx; } fn trans_shared_free(cx: @block_ctxt, v: ValueRef) -> @block_ctxt { Call(cx, bcx_ccx(cx).upcalls.shared_free, - [cx.fcx.lltaskptr, PointerCast(cx, v, T_ptr(T_i8()))]); + [PointerCast(cx, v, T_ptr(T_i8()))]); ret cx; } @@ -462,11 +462,10 @@ fn dynastack_alloca(cx: @block_ctxt, t: TypeRef, n: ValueRef, ty: ty::t) -> if cx.unreachable { ret llvm::LLVMGetUndef(t); } let bcx = cx; let dy_cx = new_raw_block_ctxt(cx.fcx, cx.fcx.lldynamicallocas); - let lltaskptr = bcx_fcx(bcx).lltaskptr; alt bcx_fcx(cx).llobstacktoken { none. { bcx_fcx(cx).llobstacktoken = - some(mk_obstack_token(bcx_ccx(cx), cx.fcx, lltaskptr)); + some(mk_obstack_token(bcx_ccx(cx), cx.fcx)); } some(_) {/* no-op */ } } @@ -477,14 +476,14 @@ fn dynastack_alloca(cx: @block_ctxt, t: TypeRef, n: ValueRef, ty: ty::t) -> let ti = none; let lltydesc = get_tydesc(cx, ty, false, tps_normal, ti).result.val; - let llresult = Call(dy_cx, dynastack_alloc, [lltaskptr, llsz, lltydesc]); + let llresult = Call(dy_cx, dynastack_alloc, [llsz, lltydesc]); ret PointerCast(dy_cx, llresult, T_ptr(t)); } -fn mk_obstack_token(ccx: @crate_ctxt, fcx: @fn_ctxt, lltaskptr: ValueRef) -> +fn mk_obstack_token(ccx: @crate_ctxt, fcx: @fn_ctxt) -> ValueRef { let cx = new_raw_block_ctxt(fcx, fcx.lldynamicallocas); - ret Call(cx, ccx.upcalls.dynastack_mark, [lltaskptr]); + ret Call(cx, ccx.upcalls.dynastack_mark, []); } @@ -836,7 +835,7 @@ fn trans_shared_malloc(cx: @block_ctxt, llptr_ty: TypeRef, llsize: ValueRef) let tydesc = C_null(T_ptr(bcx_ccx(cx).tydesc_type)); let rval = Call(cx, bcx_ccx(cx).upcalls.shared_malloc, - [cx.fcx.lltaskptr, llsize, tydesc]); + [llsize, tydesc]); ret rslt(cx, PointerCast(cx, rval, llptr_ty)); } @@ -875,7 +874,7 @@ fn trans_malloc_boxed_raw(cx: @block_ctxt, t: ty::t) -> result { let lltydesc = tydesc_result.result.val; bcx = tydesc_result.result.bcx; let rval = Call(cx, ccx.upcalls.malloc, - [cx.fcx.lltaskptr, llsz, lltydesc]); + [llsz, lltydesc]); ret rslt(cx, PointerCast(cx, rval, llty)); } @@ -1034,7 +1033,7 @@ fn get_derived_tydesc(cx: @block_ctxt, t: ty::t, escapes: bool, if escapes { let td_val = Call(bcx, bcx_ccx(bcx).upcalls.get_type_desc, - [bcx.fcx.lltaskptr, C_null(T_ptr(T_nil())), sz.val, + [C_null(T_ptr(T_nil())), sz.val, align.val, C_uint(1u + n_params), llfirstparam, C_uint(obj_params)]); v = td_val; @@ -1938,10 +1937,8 @@ fn call_cmp_glue(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, t: ty::t, } let llcmpresultptr = alloca(bcx, T_i1()); - let llargs: [ValueRef] = - [llcmpresultptr, bcx.fcx.lltaskptr, lltydesc, lltydescs, llrawlhsptr, - llrawrhsptr, llop]; - Call(bcx, llfn, llargs); + Call(bcx, llfn, [llcmpresultptr, bcx.fcx.lltaskptr, lltydesc, lltydescs, + llrawlhsptr, llrawrhsptr, llop]); ret rslt(bcx, Load(bcx, llcmpresultptr)); } @@ -4556,7 +4553,7 @@ fn trans_log(lvl: int, cx: @block_ctxt, e: @ast::expr) -> @block_ctxt { let llval_i8 = PointerCast(log_bcx, llvalptr, T_ptr(T_i8())); Call(log_bcx, bcx_ccx(log_bcx).upcalls.log_type, - [log_bcx.fcx.lltaskptr, lltydesc, llval_i8, C_int(lvl)]); + [lltydesc, llval_i8, C_int(lvl)]); log_bcx = trans_block_cleanups(log_bcx, log_cx); Br(log_bcx, after_cx.llbb); @@ -4619,7 +4616,7 @@ fn trans_fail_value(bcx: @block_ctxt, sp_opt: option::t, } let V_str = PointerCast(bcx, V_fail_str, T_ptr(T_i8())); V_filename = PointerCast(bcx, V_filename, T_ptr(T_i8())); - let args = [bcx.fcx.lltaskptr, V_str, V_filename, C_int(V_line)]; + let args = [V_str, V_filename, C_int(V_line)]; let bcx = invoke(bcx, bcx_ccx(bcx).upcalls._fail, args); Unreachable(bcx); ret bcx; @@ -4932,8 +4929,7 @@ fn trans_fn_cleanups(fcx: @fn_ctxt, cx: @block_ctxt) { alt fcx.llobstacktoken { some(lltoken_) { let lltoken = lltoken_; // satisfy alias checker - Call(cx, fcx_ccx(fcx).upcalls.dynastack_free, - [fcx.lltaskptr, lltoken]); + Call(cx, fcx_ccx(fcx).upcalls.dynastack_free, [lltoken]); } none. {/* nothing to do */ } } diff --git a/src/comp/middle/trans_vec.rs b/src/comp/middle/trans_vec.rs index eddbda3f6a25..124c10969270 100644 --- a/src/comp/middle/trans_vec.rs +++ b/src/comp/middle/trans_vec.rs @@ -163,7 +163,7 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, if strings { new_fill = Sub(bcx, new_fill, C_int(1)); } let opaque_lhs = PointerCast(bcx, lhsptr, T_ptr(T_ptr(T_opaque_vec()))); Call(bcx, bcx_ccx(cx).upcalls.vec_grow, - [cx.fcx.lltaskptr, opaque_lhs, new_fill]); + [opaque_lhs, new_fill]); // Was overwritten if we resized let lhs = Load(bcx, lhsptr); rhs = Select(bcx, self_append, lhs, rhs); @@ -204,8 +204,7 @@ fn trans_append_literal(bcx: @block_ctxt, vptrptr: ValueRef, vec_ty: ty::t, let spilled = r.val; bcx = r.bcx; Call(bcx, bcx_ccx(bcx).upcalls.vec_push, - [bcx.fcx.lltaskptr, opaque_v, td, - PointerCast(bcx, spilled, T_ptr(T_i8()))]); + [opaque_v, td, PointerCast(bcx, spilled, T_ptr(T_i8()))]); } ret bcx; } diff --git a/src/rt/rust_shape.cpp b/src/rt/rust_shape.cpp index 994c4df0fb99..8fa82b754814 100644 --- a/src/rt/rust_shape.cpp +++ b/src/rt/rust_shape.cpp @@ -552,8 +552,8 @@ upcall_cmp_type(int8_t *result, rust_task *task, const type_desc *tydesc, } extern "C" void -upcall_log_type(rust_task *task, const type_desc *tydesc, uint8_t *data, - uint32_t level) { +upcall_log_type(const type_desc *tydesc, uint8_t *data, uint32_t level) { + rust_task *task = rust_scheduler::get_task(); if (task->sched->log_lvl < level) return; // TODO: Don't evaluate at all? diff --git a/src/rt/rust_upcall.cpp b/src/rt/rust_upcall.cpp index e196adf70f0a..aaa738c2fd4f 100644 --- a/src/rt/rust_upcall.cpp +++ b/src/rt/rust_upcall.cpp @@ -55,7 +55,7 @@ upcall_fail(rust_task *task, } extern "C" CDECL uintptr_t -upcall_malloc(rust_task *unused_task, size_t nbytes, type_desc *td) { +upcall_malloc(size_t nbytes, type_desc *td) { rust_task *task = rust_scheduler::get_task(); LOG_UPCALL_ENTRY(task); @@ -85,7 +85,8 @@ upcall_malloc(rust_task *unused_task, size_t nbytes, type_desc *td) { * Called whenever an object's ref count drops to zero. */ extern "C" CDECL void -upcall_free(rust_task *task, void* ptr, uintptr_t is_gc) { +upcall_free(void* ptr, uintptr_t is_gc) { + rust_task *task = rust_scheduler::get_task(); LOG_UPCALL_ENTRY(task); rust_scheduler *sched = task->sched; @@ -100,7 +101,8 @@ upcall_free(rust_task *task, void* ptr, uintptr_t is_gc) { } extern "C" CDECL uintptr_t -upcall_shared_malloc(rust_task *task, size_t nbytes, type_desc *td) { +upcall_shared_malloc(size_t nbytes, type_desc *td) { + rust_task *task = rust_scheduler::get_task(); LOG_UPCALL_ENTRY(task); LOG(task, mem, @@ -119,7 +121,8 @@ upcall_shared_malloc(rust_task *task, size_t nbytes, type_desc *td) { * Called whenever an object's ref count drops to zero. */ extern "C" CDECL void -upcall_shared_free(rust_task *task, void* ptr) { +upcall_shared_free(void* ptr) { + rust_task *task = rust_scheduler::get_task(); LOG_UPCALL_ENTRY(task); rust_scheduler *sched = task->sched; @@ -130,13 +133,13 @@ upcall_shared_free(rust_task *task, void* ptr) { } extern "C" CDECL type_desc * -upcall_get_type_desc(rust_task *task, - void *curr_crate, // ignored, legacy compat. +upcall_get_type_desc(void *curr_crate, // ignored, legacy compat. size_t size, size_t align, size_t n_descs, type_desc const **descs, uintptr_t n_obj_params) { + rust_task *task = rust_scheduler::get_task(); check_stack(task); LOG_UPCALL_ENTRY(task); @@ -151,15 +154,16 @@ upcall_get_type_desc(rust_task *task, } extern "C" CDECL void -upcall_vec_grow(rust_task* task, rust_vec** vp, size_t new_sz) { +upcall_vec_grow(rust_vec** vp, size_t new_sz) { + rust_task *task = rust_scheduler::get_task(); LOG_UPCALL_ENTRY(task); reserve_vec(task, vp, new_sz); (*vp)->fill = new_sz; } extern "C" CDECL void -upcall_vec_push(rust_task* task, rust_vec** vp, type_desc* elt_ty, - void* elt) { +upcall_vec_push(rust_vec** vp, type_desc* elt_ty, void* elt) { + rust_task *task = rust_scheduler::get_task(); LOG_UPCALL_ENTRY(task); size_t new_sz = (*vp)->fill + elt_ty->size; reserve_vec(task, vp, new_sz); @@ -173,8 +177,8 @@ upcall_vec_push(rust_task* task, rust_vec** vp, type_desc* elt_ty, * space in the dynamic stack. */ extern "C" CDECL void * -upcall_dynastack_mark(rust_task *task) { - return task->dynastack.mark(); +upcall_dynastack_mark() { + return rust_scheduler::get_task()->dynastack.mark(); } /** @@ -183,8 +187,8 @@ upcall_dynastack_mark(rust_task *task) { * FIXME: Deprecated since dynamic stacks need to be self-describing for GC. */ extern "C" CDECL void * -upcall_dynastack_alloc(rust_task *task, size_t sz) { - return sz ? task->dynastack.alloc(sz, NULL) : NULL; +upcall_dynastack_alloc(size_t sz) { + return sz ? rust_scheduler::get_task()->dynastack.alloc(sz, NULL) : NULL; } /** @@ -192,14 +196,14 @@ upcall_dynastack_alloc(rust_task *task, size_t sz) { * returns it. */ extern "C" CDECL void * -upcall_dynastack_alloc_2(rust_task *task, size_t sz, type_desc *ty) { - return sz ? task->dynastack.alloc(sz, ty) : NULL; +upcall_dynastack_alloc_2(size_t sz, type_desc *ty) { + return sz ? rust_scheduler::get_task()->dynastack.alloc(sz, ty) : NULL; } /** Frees space in the dynamic stack. */ extern "C" CDECL void -upcall_dynastack_free(rust_task *task, void *ptr) { - return task->dynastack.free(ptr); +upcall_dynastack_free(void *ptr) { + return rust_scheduler::get_task()->dynastack.free(ptr); } /**