user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove taskptr argument from upcalls

Browse source 
Issue #466
This commit is contained in:
Marijn Haverbeke 2011-10-20 11:42:40 +02:00
parent e927df17f7
commit 6323a012bd
5 changed files with 54 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

38
src/comp/back/upcall.rs
View file

@ -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())
};
}
//

32
src/comp/middle/trans.rs
View file

@ -389,13 +389,13 @@ fn trans_native_call(cx: @block_ctxt, externs: hashmap<str, ValueRef>,
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<span>,
}
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 */ }
}

5
src/comp/middle/trans_vec.rs
View file

@ -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;
}

4
src/rt/rust_shape.cpp
View file

@ -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?

38
src/rt/rust_upcall.cpp
View file

@ -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);
}
/**