diff options
| -rw-r--r-- | src/comp/back/abi.rs | 8 | ||||
| -rw-r--r-- | src/comp/back/x86.rs | 35 | ||||
| -rw-r--r-- | src/comp/middle/trans.rs | 89 |
3 files changed, 76 insertions, 56 deletions
diff --git a/src/comp/back/abi.rs b/src/comp/back/abi.rs index 836969efd7d..95958814bc3 100644 --- a/src/comp/back/abi.rs +++ b/src/comp/back/abi.rs @@ -58,7 +58,7 @@ const int closure_elt_ty_params = 3; const int worst_case_glue_call_args = 7; -const int n_upcall_glues = 7; +const int n_native_glues = 7; const int abi_x86_rustboot_cdecl = 1; const int abi_x86_rustc_fastcall = 2; @@ -75,11 +75,11 @@ fn vec_append_glue_name() -> str { ret "rust_vec_append_glue"; } -fn upcall_glue_name(int n, bool pass_task) -> str { +fn native_glue_name(int n, bool pass_task) -> str { if (pass_task) { - ret "rust_upcall_rust_" + util.common.istr(n); + ret "rust_native_rust_" + util.common.istr(n); } - ret "rust_upcall_cdecl_" + util.common.istr(n); + ret "rust_native_cdecl_" + util.common.istr(n); } fn activate_glue_name() -> str { diff --git a/src/comp/back/x86.rs b/src/comp/back/x86.rs index b961b4743d9..e35af621e31 100644 --- a/src/comp/back/x86.rs +++ b/src/comp/back/x86.rs @@ -90,7 +90,7 @@ fn rust_activate_glue() -> vec[str] { * start doing whatever the first instruction says. Probably * saving registers and starting to establish a frame. Harmless * stuff, doesn't look at task->rust_sp again except when it - * clobbers it during a later upcall. + * clobbers it during a later native call. * * * 2. We are resuming a task that was descheduled by the yield glue @@ -100,8 +100,9 @@ fn rust_activate_glue() -> vec[str] { * "esp <- task->rust_sp" * * this is the first instruction we 'ret' to after this glue, - * because it is the first instruction following *any* upcall, - * and the task we are activating was descheduled mid-upcall. + * because it is the first instruction following *any* native + * call, and the task we are activating was descheduled + * mid-native-call. * * Unfortunately for us, we have already restored esp from * task->rust_sp and are about to eat the 5 words off the top of @@ -132,7 +133,7 @@ fn rust_activate_glue() -> vec[str] { /* * In most cases, the function we're returning to (activating) - * will have saved any caller-saves before it yielded via upcalling, + * will have saved any caller-saves before it yielded via native call, * so no work to do here. With one exception: when we're initially * activating, the task needs to be in the fastcall 2nd parameter * expected by the rust main function. That's edx. @@ -145,14 +146,14 @@ fn rust_activate_glue() -> vec[str] { /* More glue code, this time the 'bottom half' of yielding. * - * We arrived here because an upcall decided to deschedule the - * running task. So the upcall's return address got patched to the + * We arrived here because an native call decided to deschedule the + * running task. So the native call's return address got patched to the * first instruction of this glue code. * - * When the upcall does 'ret' it will come here, and its esp will be + * When the native call does 'ret' it will come here, and its esp will be * pointing to the last argument pushed on the C stack before making - * the upcall: the 0th argument to the upcall, which is always the - * task ptr performing the upcall. That's where we take over. + * the native call: the 0th argument to the native call, which is always + * the task ptr performing the native call. That's where we take over. * * Our goal is to complete the descheduling * @@ -179,7 +180,7 @@ fn rust_yield_glue() -> vec[str] { + vec("ret"); } -fn upcall_glue(int n_args, bool pass_task) -> vec[str] { +fn native_glue(int n_args, bool pass_task) -> vec[str] { /* * 0, 4, 8, 12 are callee-saves @@ -242,11 +243,11 @@ fn decl_glue(int align, str prefix, str name, vec[str] insns) -> str { } -fn decl_upcall_glue(int align, str prefix, bool pass_task, uint n) -> str { +fn decl_native_glue(int align, str prefix, bool pass_task, uint n) -> str { let int i = n as int; ret decl_glue(align, prefix, - abi.upcall_glue_name(i, pass_task), - upcall_glue(i, pass_task)); + abi.native_glue_name(i, pass_task), + native_glue(i, pass_task)); } fn get_symbol_prefix() -> str { @@ -272,10 +273,10 @@ fn get_module_asm() -> str { abi.yield_glue_name(), rust_yield_glue())) - + _vec.init_fn[str](bind decl_upcall_glue(align, prefix, true, _), - (abi.n_upcall_glues + 1) as uint) - + _vec.init_fn[str](bind decl_upcall_glue(align, prefix, false, _), - (abi.n_upcall_glues + 1) as uint); + + _vec.init_fn[str](bind decl_native_glue(align, prefix, true, _), + (abi.n_native_glues + 1) as uint) + + _vec.init_fn[str](bind decl_native_glue(align, prefix, false, _), + (abi.n_native_glues + 1) as uint); ret _str.connect(glues, "\n\n"); diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index f5fcf587612..fa389c73073 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -53,8 +53,8 @@ state obj namegen(mutable int i) { type glue_fns = rec(ValueRef activate_glue, ValueRef yield_glue, ValueRef exit_task_glue, - vec[ValueRef] upcall_glues_rust, - vec[ValueRef] upcall_glues_cdecl, + vec[ValueRef] native_glues_rust, + vec[ValueRef] native_glues_cdecl, ValueRef no_op_type_glue, ValueRef memcpy_glue, ValueRef bzero_glue, @@ -64,12 +64,31 @@ type tydesc_info = rec(ValueRef tydesc, ValueRef take_glue, ValueRef drop_glue); +/* + * A note on nomenclature of linking: "upcall", "extern" and "native". + * + * An "extern" is an LLVM symbol we wind up emitting an undefined external + * reference to. This means "we don't have the thing in this compilation unit, + * please make sure you link it in at runtime". This could be a reference to + * C code found in a C library, or rust code found in a rust crate. + * + * A "native" is a combination of an extern that references C code, plus a + * glue-code stub that "looks like" a rust function, emitted here, plus a + * generic N-ary bit of asm glue (found over in back/x86.rs) that performs a + * control transfer into C from rust. Natives may be normal C library code. + * + * An upcall is a native call generated by the compiler (not corresponding to + * any user-written call in the code) into librustrt, to perform some helper + * task such as bringing a task to life, allocating memory, etc. + * + */ + state type crate_ctxt = rec(session.session sess, ModuleRef llmod, target_data td, type_names tn, ValueRef crate_ptr, - hashmap[str, ValueRef] upcalls, + hashmap[str, ValueRef] externs, hashmap[str, ValueRef] intrinsics, hashmap[str, ValueRef] item_names, hashmap[ast.def_id, ValueRef] item_ids, @@ -852,14 +871,14 @@ fn decl_glue(ModuleRef llmod, type_names tn, str s) -> ValueRef { ret decl_cdecl_fn(llmod, s, T_fn(vec(T_taskptr(tn)), T_void())); } -fn decl_upcall_glue(ModuleRef llmod, type_names tn, +fn decl_native_glue(ModuleRef llmod, type_names tn, bool pass_task, uint _n) -> ValueRef { // It doesn't actually matter what type we come up with here, at the - // moment, as we cast the upcall function pointers to int before passing - // them to the indirect upcall-invocation glue. But eventually we'd like + // moment, as we cast the native function pointers to int before passing + // them to the indirect native-invocation glue. But eventually we'd like // to call them directly, once we have a calling convention worked out. let int n = _n as int; - let str s = abi.upcall_glue_name(n, pass_task); + let str s = abi.native_glue_name(n, pass_task); let vec[TypeRef] args = vec(T_int()); // callee if (!pass_task) { args += vec(T_int()); // taskptr, will not be passed @@ -869,15 +888,15 @@ fn decl_upcall_glue(ModuleRef llmod, type_names tn, ret decl_fastcall_fn(llmod, s, T_fn(args, T_int())); } -fn get_upcall(&hashmap[str, ValueRef] upcalls, +fn get_extern(&hashmap[str, ValueRef] externs, ModuleRef llmod, str name, int n_args) -> ValueRef { - if (upcalls.contains_key(name)) { - ret upcalls.get(name); + if (externs.contains_key(name)) { + ret externs.get(name); } auto inputs = _vec.init_elt[TypeRef](T_int(), n_args as uint); auto output = T_int(); auto f = decl_cdecl_fn(llmod, name, T_fn(inputs, output)); - upcalls.insert(name, f); + externs.insert(name, f); ret f; } @@ -885,26 +904,26 @@ fn trans_upcall(@block_ctxt cx, str name, vec[ValueRef] args) -> result { auto cxx = cx.fcx.ccx; auto lltaskptr = cx.build.PtrToInt(cx.fcx.lltaskptr, T_int()); auto args2 = vec(lltaskptr) + args; - auto t = trans_upcall2(cx.build, cxx.glues, lltaskptr, - cxx.upcalls, cxx.tn, cxx.llmod, name, true, args2); + auto t = trans_native(cx.build, cxx.glues, lltaskptr, + cxx.externs, cxx.tn, cxx.llmod, name, true, args2); ret res(cx, t); } -fn trans_upcall2(builder b, @glue_fns glues, ValueRef lltaskptr, - &hashmap[str, ValueRef] upcalls, - type_names tn, ModuleRef llmod, str name, - bool pass_task, vec[ValueRef] args) -> ValueRef { +fn trans_native(builder b, @glue_fns glues, ValueRef lltaskptr, + &hashmap[str, ValueRef] externs, + type_names tn, ModuleRef llmod, str name, + bool pass_task, vec[ValueRef] args) -> ValueRef { let int n = (_vec.len[ValueRef](args) as int); - let ValueRef llupcall = get_upcall(upcalls, llmod, name, n); - llupcall = llvm.LLVMConstPointerCast(llupcall, T_int()); + let ValueRef llnative = get_extern(externs, llmod, name, n); + llnative = llvm.LLVMConstPointerCast(llnative, T_int()); let ValueRef llglue; if (pass_task) { - llglue = glues.upcall_glues_rust.(n); + llglue = glues.native_glues_rust.(n); } else { - llglue = glues.upcall_glues_cdecl.(n); + llglue = glues.native_glues_cdecl.(n); } - let vec[ValueRef] call_args = vec(llupcall); + let vec[ValueRef] call_args = vec(llnative); if (!pass_task) { call_args += vec(lltaskptr); @@ -5771,8 +5790,8 @@ fn decl_native_fn_and_pair(@crate_ctxt cx, arg_n += 1u; } - auto r = trans_upcall2(bcx.build, cx.glues, lltaskptr, cx.upcalls, cx.tn, - cx.llmod, name, pass_task, call_args); + auto r = trans_native(bcx.build, cx.glues, lltaskptr, cx.externs, cx.tn, + cx.llmod, name, pass_task, call_args); auto rptr = bcx.build.BitCast(fcx.llretptr, T_ptr(T_i32())); bcx.build.Store(r, rptr); bcx.build.RetVoid(); @@ -5967,7 +5986,7 @@ fn i2p(ValueRef v, TypeRef t) -> ValueRef { } fn trans_exit_task_glue(@glue_fns glues, - &hashmap[str, ValueRef] upcalls, + &hashmap[str, ValueRef] externs, type_names tn, ModuleRef llmod) { let vec[TypeRef] T_args = vec(); let vec[ValueRef] V_args = vec(); @@ -5979,8 +5998,8 @@ fn trans_exit_task_glue(@glue_fns glues, auto build = new_builder(entrybb); auto tptr = build.PtrToInt(lltaskptr, T_int()); auto V_args2 = vec(tptr) + V_args; - trans_upcall2(build, glues, lltaskptr, - upcalls, tn, llmod, "upcall_exit", true, V_args2); + trans_native(build, glues, lltaskptr, + externs, tn, llmod, "upcall_exit", true, V_args2); build.RetVoid(); } @@ -6415,7 +6434,7 @@ fn make_glues(ModuleRef llmod, type_names tn) -> @glue_fns { yield_glue = decl_glue(llmod, tn, abi.yield_glue_name()), /* * Note: the signature passed to decl_cdecl_fn here looks unusual - * because it is. It corresponds neither to an upcall signature + * because it is. It corresponds neither to a native signature * nor a normal rust-ABI signature. In fact it is a fake * signature, that exists solely to acquire the task pointer as * an argument to the upcall. It so happens that the runtime sets @@ -6430,14 +6449,14 @@ fn make_glues(ModuleRef llmod, type_names tn) -> @glue_fns { T_taskptr(tn)), T_void())), - upcall_glues_rust = - _vec.init_fn[ValueRef](bind decl_upcall_glue(llmod, tn, true, + native_glues_rust = + _vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, true, _), - abi.n_upcall_glues + 1 as uint), - upcall_glues_cdecl = - _vec.init_fn[ValueRef](bind decl_upcall_glue(llmod, tn, false, + abi.n_native_glues + 1 as uint), + native_glues_cdecl = + _vec.init_fn[ValueRef](bind decl_native_glue(llmod, tn, false, _), - abi.n_upcall_glues + 1 as uint), + abi.n_native_glues + 1 as uint), no_op_type_glue = decl_no_op_type_glue(llmod, tn), memcpy_glue = decl_memcpy_glue(llmod), bzero_glue = decl_bzero_glue(llmod), @@ -6503,7 +6522,7 @@ fn trans_crate(session.session sess, @ast.crate crate, str output, td = td, tn = tn, crate_ptr = crate_ptr, - upcalls = new_str_hash[ValueRef](), + externs = new_str_hash[ValueRef](), intrinsics = intrinsics, item_names = new_str_hash[ValueRef](), item_ids = new_def_hash[ValueRef](), |