// trans.rs: Translate the completed AST to the LLVM IR. // // Some functions here, such as trans_block and trans_expr, return a value -- // the result of the translation to LLVM -- while others, such as trans_fn, // trans_obj, and trans_item, are called only for the side effect of adding a // particular definition to the LLVM IR output we're producing. // // Hopefully useful general knowledge about trans: // // * There's no way to find out the ty::t type of a ValueRef. Doing so // would be "trying to get the eggs out of an omelette" (credit: // pcwalton). You can, instead, find out its TypeRef by calling val_ty, // but many TypeRefs correspond to one ty::t; for instance, tup(int, int, // int) and rec(x=int, y=int, z=int) will have the same TypeRef. import std::int; import std::str; import std::uint; import std::str::rustrt::sbuf; import std::map; import std::map::hashmap; import std::option; import std::option::some; import std::option::none; import std::fs; import std::time; import syntax::ast; import driver::session; import middle::ty; import middle::freevars::*; import middle::gc; import back::link; import back::x86; import back::abi; import back::upcall; import syntax::visit; import visit::vt; import util::common; import util::common::*; import std::map::new_int_hash; import std::map::new_str_hash; import syntax::codemap::span; import lib::llvm::llvm; import lib::llvm::builder; import lib::llvm::new_builder; import lib::llvm::target_data; import lib::llvm::type_names; import lib::llvm::mk_target_data; import lib::llvm::mk_type_names; import lib::llvm::llvm::ModuleRef; import lib::llvm::llvm::ValueRef; import lib::llvm::llvm::TypeRef; import lib::llvm::llvm::TypeHandleRef; import lib::llvm::llvm::BuilderRef; import lib::llvm::llvm::BasicBlockRef; import lib::llvm::False; import lib::llvm::True; import lib::llvm::Bool; import link::mangle_internal_name_by_type_only; import link::mangle_internal_name_by_seq; import link::mangle_internal_name_by_path; import link::mangle_internal_name_by_path_and_seq; import link::mangle_exported_name; import metadata::creader; import metadata::csearch; import metadata::cstore; import util::ppaux::ty_to_str; import util::ppaux::ty_to_short_str; import syntax::print::pprust::expr_to_str; import syntax::print::pprust::path_to_str; import trans_common::*; import trans_objects::trans_anon_obj; import trans_objects::trans_obj; // This function now fails if called on a type with dynamic size (as its // return value was always meaningless in that case anyhow). Beware! // // TODO: Enforce via a predicate. fn type_of(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef { if ty::type_has_dynamic_size(cx.tcx, t) { cx.sess.span_fatal(sp, "type_of() called on a type with dynamic size: " + ty_to_str(cx.tcx, t)); } ret type_of_inner(cx, sp, t); } fn type_of_explicit_args(cx: &@crate_ctxt, sp: &span, inputs: &[ty::arg]) -> [TypeRef] { let atys: [TypeRef] = ~[]; for arg: ty::arg in inputs { let t: TypeRef = type_of_inner(cx, sp, arg.ty); t = alt arg.mode { ty::mo_alias(_) { T_ptr(t) } ty::mo_move. { T_ptr(t) } _ { t } }; atys += ~[t]; } ret atys; } // NB: must keep 4 fns in sync: // // - type_of_fn_full // - create_llargs_for_fn_args. // - new_fn_ctxt // - trans_args fn type_of_fn_full(cx: &@crate_ctxt, sp: &span, proto: ast::proto, is_method: bool, inputs: &[ty::arg], output: &ty::t, ty_param_count: uint) -> TypeRef { let atys: [TypeRef] = ~[]; // Arg 0: Output pointer. atys += ~[T_ptr(type_of_inner(cx, sp, output))]; // Arg 1: task pointer. atys += ~[T_taskptr(*cx)]; // Arg 2: Env (closure-bindings / self-obj) if is_method { atys += ~[T_ptr(cx.rust_object_type)]; } else { atys += ~[T_opaque_closure_ptr(*cx)]; } // Args >3: ty params, if not acquired via capture... if !is_method { let i = 0u; while i < ty_param_count { atys += ~[T_ptr(cx.tydesc_type)]; i += 1u; } } if proto == ast::proto_iter { // If it's an iter, the 'output' type of the iter is actually the // *input* type of the function we're given as our iter-block // argument. atys += ~[type_of_inner(cx, sp, ty::mk_iter_body_fn(cx.tcx, output))]; } // ... then explicit args. atys += type_of_explicit_args(cx, sp, inputs); ret T_fn(atys, llvm::LLVMVoidType()); } fn type_of_fn(cx: &@crate_ctxt, sp: &span, proto: ast::proto, inputs: &[ty::arg], output: &ty::t, ty_param_count: uint) -> TypeRef { ret type_of_fn_full(cx, sp, proto, false, inputs, output, ty_param_count); } // Given a function type and a count of ty params, construct an llvm type fn type_of_fn_from_ty(cx: &@crate_ctxt, sp: &span, fty: &ty::t, ty_param_count: uint) -> TypeRef { ret type_of_fn(cx, sp, ty::ty_fn_proto(cx.tcx, fty), ty::ty_fn_args(cx.tcx, fty), ty::ty_fn_ret(cx.tcx, fty), ty_param_count); } fn type_of_native_fn(cx: &@crate_ctxt, sp: &span, abi: ast::native_abi, inputs: &[ty::arg], output: &ty::t, ty_param_count: uint) -> TypeRef { let atys: [TypeRef] = ~[]; if abi == ast::native_abi_rust { atys += ~[T_taskptr(*cx)]; let i = 0u; while i < ty_param_count { atys += ~[T_ptr(cx.tydesc_type)]; i += 1u; } } atys += type_of_explicit_args(cx, sp, inputs); ret T_fn(atys, type_of_inner(cx, sp, output)); } fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef { // Check the cache. if cx.lltypes.contains_key(t) { ret cx.lltypes.get(t); } let llty: TypeRef = 0 as TypeRef; alt ty::struct(cx.tcx, t) { ty::ty_native(_) { llty = T_ptr(T_i8()); } ty::ty_nil. { llty = T_nil(); } ty::ty_bot. { llty = T_nil(); /* ...I guess? */ } ty::ty_bool. { llty = T_bool(); } ty::ty_int. { llty = T_int(); } ty::ty_float. { llty = T_float(); } ty::ty_uint. { llty = T_int(); } ty::ty_machine(tm) { alt tm { ast::ty_i8. { llty = T_i8(); } ast::ty_u8. { llty = T_i8(); } ast::ty_i16. { llty = T_i16(); } ast::ty_u16. { llty = T_i16(); } ast::ty_i32. { llty = T_i32(); } ast::ty_u32. { llty = T_i32(); } ast::ty_i64. { llty = T_i64(); } ast::ty_u64. { llty = T_i64(); } ast::ty_f32. { llty = T_f32(); } ast::ty_f64. { llty = T_f64(); } } } ty::ty_char. { llty = T_char(); } ty::ty_str. { llty = T_ptr(T_str()); } ty::ty_istr. { llty = T_ivec(T_i8()); } ty::ty_tag(did, _) { llty = type_of_tag(cx, sp, did, t); } ty::ty_box(mt) { llty = T_ptr(T_box(type_of_inner(cx, sp, mt.ty))); } ty::ty_uniq(t) { llty = T_ptr(type_of_inner(cx, sp, t)); } ty::ty_vec(mt) { llty = T_ptr(T_vec(type_of_inner(cx, sp, mt.ty))); } ty::ty_ivec(mt) { if ty::type_has_dynamic_size(cx.tcx, mt.ty) { llty = T_opaque_ivec(); } else { llty = T_ivec(type_of_inner(cx, sp, mt.ty)); } } ty::ty_ptr(mt) { llty = T_ptr(type_of_inner(cx, sp, mt.ty)); } ty::ty_port(t) { llty = T_ptr(T_port(type_of_inner(cx, sp, t))); } ty::ty_chan(t) { llty = T_ptr(T_chan(type_of_inner(cx, sp, t))); } ty::ty_task. { llty = T_taskptr(*cx); } ty::ty_rec(fields) { let tys: [TypeRef] = ~[]; for f: ty::field in fields { tys += ~[type_of_inner(cx, sp, f.mt.ty)]; } llty = T_struct(tys); } ty::ty_fn(_, _, _, _, _) { llty = T_fn_pair(*cx, type_of_fn_from_ty(cx, sp, t, 0u)); } ty::ty_native_fn(abi, args, out) { let nft = native_fn_wrapper_type(cx, sp, 0u, t); llty = T_fn_pair(*cx, nft); } ty::ty_obj(meths) { llty = cx.rust_object_type; } ty::ty_res(_, sub, tps) { let sub1 = ty::substitute_type_params(cx.tcx, tps, sub); ret T_struct(~[T_i32(), type_of_inner(cx, sp, sub1)]); } ty::ty_var(_) { cx.tcx.sess.span_fatal(sp, "trans::type_of called on ty_var"); } ty::ty_param(_, _) { llty = T_typaram(cx.tn); } ty::ty_type. { llty = T_ptr(cx.tydesc_type); } ty::ty_tup(elts) { let tys = ~[]; for elt in elts { tys += ~[type_of_inner(cx, sp, elt)]; } llty = T_struct(tys); } } assert (llty as int != 0); cx.lltypes.insert(t, llty); ret llty; } fn type_of_tag(cx: &@crate_ctxt, sp: &span, did: &ast::def_id, t: &ty::t) -> TypeRef { let degen = std::ivec::len(ty::tag_variants(cx.tcx, did)) == 1u; if ty::type_has_dynamic_size(cx.tcx, t) { if degen { ret T_i8(); } else { ret T_opaque_tag(cx.tn); } } else { let size = static_size_of_tag(cx, sp, t); if !degen { ret T_tag(cx.tn, size); } // LLVM does not like 0-size arrays, apparently if size == 0u { size = 1u; } ret T_array(T_i8(), size); } } fn type_of_ty_param_kinds_and_ty(lcx: @local_ctxt, sp: &span, tpt: &ty::ty_param_kinds_and_ty) -> TypeRef { alt ty::struct(lcx.ccx.tcx, tpt.ty) { ty::ty_fn(_, _, _, _, _) { let llfnty = type_of_fn_from_ty(lcx.ccx, sp, tpt.ty, std::ivec::len(tpt.kinds)); ret T_fn_pair(*lcx.ccx, llfnty); } _ { // fall through } } ret type_of(lcx.ccx, sp, tpt.ty); } fn type_of_or_i8(bcx: &@block_ctxt, typ: ty::t) -> TypeRef { if ty::type_has_dynamic_size(bcx_tcx(bcx), typ) { ret T_i8(); } ret type_of(bcx_ccx(bcx), bcx.sp, typ); } // Name sanitation. LLVM will happily accept identifiers with weird names, but // gas doesn't! fn sanitize(s: &str) -> str { let result = ""; for c: u8 in s { if c == '@' as u8 { result += "boxed_"; } else { if c == ',' as u8 { result += "_"; } else { if c == '{' as u8 || c == '(' as u8 { result += "_of_"; } else { if c != 10u8 && c != '}' as u8 && c != ')' as u8 && c != ' ' as u8 && c != '\t' as u8 && c != ';' as u8 { let v = ~[c]; result += str::unsafe_from_bytes(v); } } } } } ret result; } fn log_fn_time(ccx: &@crate_ctxt, name: str, start: &time::timeval, end: &time::timeval) { let elapsed = 1000 * (end.sec - start.sec as int) + ((end.usec as int) - (start.usec as int)) / 1000; *ccx.stats.fn_times += ~[{ident: name, time: elapsed}]; } fn decl_fn(llmod: ModuleRef, name: &str, cc: uint, llty: TypeRef) -> ValueRef { let llfn: ValueRef = llvm::LLVMAddFunction(llmod, str::buf(name), llty); llvm::LLVMSetFunctionCallConv(llfn, cc); ret llfn; } fn decl_cdecl_fn(llmod: ModuleRef, name: &str, llty: TypeRef) -> ValueRef { ret decl_fn(llmod, name, lib::llvm::LLVMCCallConv, llty); } fn decl_fastcall_fn(llmod: ModuleRef, name: &str, llty: TypeRef) -> ValueRef { let llfn = decl_fn(llmod, name, lib::llvm::LLVMFastCallConv, llty); llvm::LLVMSetGC(llfn, str::buf("rust")); ret llfn; } // Only use this if you are going to actually define the function. It's // not valid to simply declare a function as internal. fn decl_internal_fastcall_fn(llmod: ModuleRef, name: &str, llty: TypeRef) -> ValueRef { let llfn = decl_fn(llmod, name, lib::llvm::LLVMFastCallConv, llty); llvm::LLVMSetLinkage(llfn, lib::llvm::LLVMInternalLinkage as llvm::Linkage); ret llfn; } fn decl_glue(llmod: ModuleRef, cx: &crate_ctxt, s: &str) -> ValueRef { ret decl_cdecl_fn(llmod, s, T_fn(~[T_taskptr(cx)], T_void())); } fn get_extern_fn(externs: &hashmap[str, ValueRef], llmod: ModuleRef, name: &str, cc: uint, ty: TypeRef) -> ValueRef { if externs.contains_key(name) { ret externs.get(name); } let f = decl_fn(llmod, name, cc, ty); externs.insert(name, f); ret f; } fn get_extern_const(externs: &hashmap[str, ValueRef], llmod: ModuleRef, name: &str, ty: TypeRef) -> ValueRef { if externs.contains_key(name) { ret externs.get(name); } let c = llvm::LLVMAddGlobal(llmod, ty, str::buf(name)); externs.insert(name, c); ret c; } fn get_simple_extern_fn(externs: &hashmap[str, ValueRef], llmod: ModuleRef, name: &str, n_args: int) -> ValueRef { let inputs = std::ivec::init_elt[TypeRef](T_int(), n_args as uint); let output = T_int(); let t = T_fn(inputs, output); ret get_extern_fn(externs, llmod, name, lib::llvm::LLVMCCallConv, t); } fn trans_native_call(b: &builder, glues: @glue_fns, lltaskptr: ValueRef, externs: &hashmap[str, ValueRef], tn: &type_names, llmod: ModuleRef, name: &str, pass_task: bool, args: &[ValueRef]) -> ValueRef { let n: int = std::ivec::len[ValueRef](args) as int; let llnative: ValueRef = get_simple_extern_fn(externs, llmod, name, n); let call_args: [ValueRef] = ~[]; for a: ValueRef in args { call_args += ~[b.ZExtOrBitCast(a, T_int())]; } ret b.Call(llnative, call_args); } fn trans_non_gc_free(cx: &@block_ctxt, v: ValueRef) -> result { cx.build.Call(bcx_ccx(cx).upcalls.free, ~[cx.fcx.lltaskptr, cx.build.PointerCast(v, T_ptr(T_i8())), C_int(0)]); ret rslt(cx, C_int(0)); } fn trans_shared_free(cx: &@block_ctxt, v: ValueRef) -> result { cx.build.Call(bcx_ccx(cx).upcalls.shared_free, ~[cx.fcx.lltaskptr, cx.build.PointerCast(v, T_ptr(T_i8()))]); ret rslt(cx, C_int(0)); } fn umax(cx: &@block_ctxt, a: ValueRef, b: ValueRef) -> ValueRef { let cond = cx.build.ICmp(lib::llvm::LLVMIntULT, a, b); ret cx.build.Select(cond, b, a); } fn umin(cx: &@block_ctxt, a: ValueRef, b: ValueRef) -> ValueRef { let cond = cx.build.ICmp(lib::llvm::LLVMIntULT, a, b); ret cx.build.Select(cond, a, b); } fn align_to(cx: &@block_ctxt, off: ValueRef, align: ValueRef) -> ValueRef { let mask = cx.build.Sub(align, C_int(1)); let bumped = cx.build.Add(off, mask); ret cx.build.And(bumped, cx.build.Not(mask)); } // Returns the real size of the given type for the current target. fn llsize_of_real(cx: &@crate_ctxt, t: TypeRef) -> uint { ret llvm::LLVMStoreSizeOfType(cx.td.lltd, t); } // Returns the real alignment of the given type for the current target. fn llalign_of_real(cx: &@crate_ctxt, t: TypeRef) -> uint { ret llvm::LLVMPreferredAlignmentOfType(cx.td.lltd, t); } fn llsize_of(t: TypeRef) -> ValueRef { ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMSizeOf(t), T_int(), False); } fn llalign_of(t: TypeRef) -> ValueRef { ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMAlignOf(t), T_int(), False); } fn size_of(cx: &@block_ctxt, t: &ty::t) -> result { if !ty::type_has_dynamic_size(bcx_tcx(cx), t) { ret rslt(cx, llsize_of(type_of(bcx_ccx(cx), cx.sp, t))); } ret dynamic_size_of(cx, t); } fn align_of(cx: &@block_ctxt, t: &ty::t) -> result { if !ty::type_has_dynamic_size(bcx_tcx(cx), t) { ret rslt(cx, llalign_of(type_of(bcx_ccx(cx), cx.sp, t))); } ret dynamic_align_of(cx, t); } fn alloca(cx: &@block_ctxt, t: TypeRef) -> ValueRef { ret new_builder(cx.fcx.llstaticallocas).Alloca(t); } fn array_alloca(cx: &@block_ctxt, t: TypeRef, n: ValueRef) -> ValueRef { ret new_builder(cx.fcx.lldynamicallocas).ArrayAlloca(t, n); } // Creates a simpler, size-equivalent type. The resulting type is guaranteed // to have (a) the same size as the type that was passed in; (b) to be non- // recursive. This is done by replacing all boxes in a type with boxed unit // types. fn simplify_type(ccx: &@crate_ctxt, typ: &ty::t) -> ty::t { fn simplifier(ccx: @crate_ctxt, typ: ty::t) -> ty::t { alt ty::struct(ccx.tcx, typ) { ty::ty_box(_) { ret ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)); } ty::ty_uniq(_) { ret ty::mk_uniq(ccx.tcx, ty::mk_nil(ccx.tcx)); } ty::ty_vec(_) { ret ty::mk_imm_vec(ccx.tcx, ty::mk_nil(ccx.tcx)); } ty::ty_fn(_, _, _, _, _) { ret ty::mk_tup(ccx.tcx, ~[ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)), ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx))]); } ty::ty_obj(_) { ret ty::mk_tup(ccx.tcx, ~[ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)), ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx))]); } ty::ty_res(_, sub, tps) { let sub1 = ty::substitute_type_params(ccx.tcx, tps, sub); ret ty::mk_tup(ccx.tcx, ~[ty::mk_int(ccx.tcx), simplify_type(ccx, sub1)]); } _ { ret typ; } } } ret ty::fold_ty(ccx.tcx, ty::fm_general(bind simplifier(ccx, _)), typ); } // Computes the size of the data part of a non-dynamically-sized tag. fn static_size_of_tag(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> uint { if ty::type_has_dynamic_size(cx.tcx, t) { cx.tcx.sess.span_fatal(sp, "dynamically sized type passed to \ static_size_of_tag()"); } if cx.tag_sizes.contains_key(t) { ret cx.tag_sizes.get(t); } alt ty::struct(cx.tcx, t) { ty::ty_tag(tid, subtys) { // Compute max(variant sizes). let max_size = 0u; let variants = ty::tag_variants(cx.tcx, tid); for variant: ty::variant_info in variants { let tup_ty = simplify_type(cx, ty::mk_tup(cx.tcx, variant.args)); // Perform any type parameter substitutions. tup_ty = ty::substitute_type_params(cx.tcx, subtys, tup_ty); // Here we possibly do a recursive call. let this_size = llsize_of_real(cx, type_of(cx, sp, tup_ty)); if max_size < this_size { max_size = this_size; } } cx.tag_sizes.insert(t, max_size); ret max_size; } _ { cx.tcx.sess.span_fatal(sp, "non-tag passed to static_size_of_tag()"); } } } fn dynamic_size_of(cx: &@block_ctxt, t: ty::t) -> result { fn align_elements(cx: &@block_ctxt, elts: &[ty::t]) -> result { // // C padding rules: // // // - Pad after each element so that next element is aligned. // - Pad after final structure member so that whole structure // is aligned to max alignment of interior. // let off = C_int(0); let max_align = C_int(1); let bcx = cx; for e: ty::t in elts { let elt_align = align_of(bcx, e); bcx = elt_align.bcx; let elt_size = size_of(bcx, e); bcx = elt_size.bcx; let aligned_off = align_to(bcx, off, elt_align.val); off = bcx.build.Add(aligned_off, elt_size.val); max_align = umax(bcx, max_align, elt_align.val); } off = align_to(bcx, off, max_align); ret rslt(bcx, off); } alt ty::struct(bcx_tcx(cx), t) { ty::ty_param(p,_) { let szptr = field_of_tydesc(cx, t, false, abi::tydesc_field_size); ret rslt(szptr.bcx, szptr.bcx.build.Load(szptr.val)); } ty::ty_rec(flds) { let tys: [ty::t] = ~[]; for f: ty::field in flds { tys += ~[f.mt.ty]; } ret align_elements(cx, tys); } ty::ty_tup(elts) { let tys = ~[]; for tp in elts { tys += ~[tp]; } ret align_elements(cx, tys); } ty::ty_tag(tid, tps) { let bcx = cx; // Compute max(variant sizes). let max_size: ValueRef = alloca(bcx, T_int()); bcx.build.Store(C_int(0), max_size); let variants = ty::tag_variants(bcx_tcx(bcx), tid); for variant: ty::variant_info in variants { // Perform type substitution on the raw argument types. let raw_tys: [ty::t] = variant.args; let tys: [ty::t] = ~[]; for raw_ty: ty::t in raw_tys { let t = ty::substitute_type_params(bcx_tcx(cx), tps, raw_ty); tys += ~[t]; } let rslt = align_elements(bcx, tys); bcx = rslt.bcx; let this_size = rslt.val; let old_max_size = bcx.build.Load(max_size); bcx.build.Store(umax(bcx, this_size, old_max_size), max_size); } let max_size_val = bcx.build.Load(max_size); let total_size = if std::ivec::len(variants) != 1u { bcx.build.Add(max_size_val, llsize_of(T_int())) } else { max_size_val }; ret rslt(bcx, total_size); } ty::ty_ivec(mt) { let rs = size_of(cx, mt.ty); let bcx = rs.bcx; let llunitsz = rs.val; let llsz = bcx.build.Add(llsize_of(T_opaque_ivec()), bcx.build.Mul(llunitsz, C_uint(abi::ivec_default_length))); ret rslt(bcx, llsz); } } } fn dynamic_align_of(cx: &@block_ctxt, t: &ty::t) -> result { alt ty::struct(bcx_tcx(cx), t) { ty::ty_param(p,_) { let aptr = field_of_tydesc(cx, t, false, abi::tydesc_field_align); ret rslt(aptr.bcx, aptr.bcx.build.Load(aptr.val)); } ty::ty_rec(flds) { let a = C_int(1); let bcx = cx; for f: ty::field in flds { let align = align_of(bcx, f.mt.ty); bcx = align.bcx; a = umax(bcx, a, align.val); } ret rslt(bcx, a); } ty::ty_tag(_, _) { ret rslt(cx, C_int(1)); // FIXME: stub } ty::ty_ivec(tm) { let rs = align_of(cx, tm.ty); let bcx = rs.bcx; let llunitalign = rs.val; let llalign = umax(bcx, llalign_of(T_int()), llunitalign); ret rslt(bcx, llalign); } ty::ty_tup(elts) { let a = C_int(1); let bcx = cx; for e in elts { let align = align_of(bcx, e); bcx = align.bcx; a = umax(bcx, a, align.val); } ret rslt(bcx, a); } } } // Simple wrapper around GEP that takes an array of ints and wraps them // in C_int() fn GEPi(cx: &@block_ctxt, base: ValueRef, ixs: &[int]) -> ValueRef { let v: [ValueRef] = ~[]; for i: int in ixs { v += ~[C_int(i)]; } ret cx.build.InBoundsGEP(base, v); } // Increment a pointer by a given amount and then cast it to be a pointer // to a given type. fn bump_ptr(bcx: &@block_ctxt, t: &ty::t, base: ValueRef, sz: ValueRef) -> ValueRef { let raw = bcx.build.PointerCast(base, T_ptr(T_i8())); let bumped = bcx.build.GEP(raw, ~[sz]); if ty::type_has_dynamic_size(bcx_tcx(bcx), t) { ret bumped; } let typ = T_ptr(type_of(bcx_ccx(bcx), bcx.sp, t)); ret bcx.build.PointerCast(bumped, typ); } // Replacement for the LLVM 'GEP' instruction when field-indexing into a // tuple-like structure (tup, rec) with a static index. This one is driven off // ty::struct and knows what to do when it runs into a ty_param stuck in the // middle of the thing it's GEP'ing into. Much like size_of and align_of, // above. fn GEP_tup_like(cx: &@block_ctxt, t: &ty::t, base: ValueRef, ixs: &[int]) -> result { assert (ty::type_is_tup_like(bcx_tcx(cx), t)); // It might be a static-known type. Handle this. if !ty::type_has_dynamic_size(bcx_tcx(cx), t) { ret rslt(cx, GEPi(cx, base, ixs)); } // It is a dynamic-containing type that, if we convert directly to an LLVM // TypeRef, will be all wrong; there's no proper LLVM type to represent // it, and the lowering function will stick in i8* values for each // ty_param, which is not right; the ty_params are all of some dynamic // size. // // What we must do instead is sadder. We must look through the indices // manually and split the input type into a prefix and a target. We then // measure the prefix size, bump the input pointer by that amount, and // cast to a pointer-to-target type. // Given a type, an index vector and an element number N in that vector, // calculate index X and the type that results by taking the first X-1 // elements of the type and splitting the Xth off. Return the prefix as // well as the innermost Xth type. fn split_type(ccx: &@crate_ctxt, t: &ty::t, ixs: &[int], n: uint) -> {prefix: [ty::t], target: ty::t} { let len: uint = std::ivec::len[int](ixs); // We don't support 0-index or 1-index GEPs: The former is nonsense // and the latter would only be meaningful if we supported non-0 // values for the 0th index (we don't). assert (len > 1u); if n == 0u { // Since we're starting from a value that's a pointer to a // *single* structure, the first index (in GEP-ese) should just be // 0, to yield the pointee. assert (ixs.(n) == 0); ret split_type(ccx, t, ixs, n + 1u); } assert (n < len); let ix: int = ixs.(n); let prefix: [ty::t] = ~[]; let i: int = 0; while i < ix { prefix += ~[ty::get_element_type(ccx.tcx, t, i as uint)]; i += 1; } let selected = ty::get_element_type(ccx.tcx, t, i as uint); if n == len - 1u { // We are at the innermost index. ret {prefix: prefix, target: selected}; } else { // Not the innermost index; call self recursively to dig deeper. // Once we get an inner result, append it current prefix and // return to caller. let inner = split_type(ccx, selected, ixs, n + 1u); prefix += inner.prefix; ret {prefix: prefix with inner}; } } // We make a fake prefix tuple-type here; luckily for measuring sizes // the tuple parens are associative so it doesn't matter that we've // flattened the incoming structure. let s = split_type(bcx_ccx(cx), t, ixs, 0u); let args = ~[]; for typ: ty::t in s.prefix { args += ~[typ]; } let prefix_ty = ty::mk_tup(bcx_tcx(cx), args); let bcx = cx; let sz = size_of(bcx, prefix_ty); ret rslt(sz.bcx, bump_ptr(sz.bcx, s.target, base, sz.val)); } // Replacement for the LLVM 'GEP' instruction when field indexing into a tag. // This function uses GEP_tup_like() above and automatically performs casts as // appropriate. @llblobptr is the data part of a tag value; its actual type is // meaningless, as it will be cast away. fn GEP_tag(cx: @block_ctxt, llblobptr: ValueRef, tag_id: &ast::def_id, variant_id: &ast::def_id, ty_substs: &[ty::t], ix: int) -> result { let variant = ty::tag_variant_with_id(bcx_tcx(cx), tag_id, variant_id); // Synthesize a tuple type so that GEP_tup_like() can work its magic. // Separately, store the type of the element we're interested in. let arg_tys = variant.args; let elem_ty = ty::mk_nil(bcx_tcx(cx)); // typestate infelicity let i = 0; let true_arg_tys: [ty::t] = ~[]; for aty: ty::t in arg_tys { let arg_ty = ty::substitute_type_params(bcx_tcx(cx), ty_substs, aty); true_arg_tys += ~[arg_ty]; if i == ix { elem_ty = arg_ty; } i += 1; } let tup_ty = ty::mk_tup(bcx_tcx(cx), true_arg_tys); // Cast the blob pointer to the appropriate type, if we need to (i.e. if // the blob pointer isn't dynamically sized). let llunionptr: ValueRef; if !ty::type_has_dynamic_size(bcx_tcx(cx), tup_ty) { let llty = type_of(bcx_ccx(cx), cx.sp, tup_ty); llunionptr = cx.build.TruncOrBitCast(llblobptr, T_ptr(llty)); } else { llunionptr = llblobptr; } // Do the GEP_tup_like(). let rs = GEP_tup_like(cx, tup_ty, llunionptr, ~[0, ix]); // Cast the result to the appropriate type, if necessary. let val; if !ty::type_has_dynamic_size(bcx_tcx(cx), elem_ty) { let llelemty = type_of(bcx_ccx(rs.bcx), cx.sp, elem_ty); val = rs.bcx.build.PointerCast(rs.val, T_ptr(llelemty)); } else { val = rs.val; } ret rslt(rs.bcx, val); } // trans_raw_malloc: expects a type indicating which pointer type we want and // a size indicating how much space we want malloc'd. fn trans_raw_malloc(cx: &@block_ctxt, llptr_ty: TypeRef, llsize: ValueRef) -> result { // FIXME: need a table to collect tydesc globals. let tydesc = C_null(T_ptr(bcx_ccx(cx).tydesc_type)); let rval = cx.build.Call(bcx_ccx(cx).upcalls.malloc, ~[cx.fcx.lltaskptr, llsize, tydesc]); ret rslt(cx, cx.build.PointerCast(rval, llptr_ty)); } // trans_shared_malloc: expects a type indicating which pointer type we want // and a size indicating how much space we want malloc'd. fn trans_shared_malloc(cx: &@block_ctxt, llptr_ty: TypeRef, llsize: ValueRef) -> result { // FIXME: need a table to collect tydesc globals. let tydesc = C_null(T_ptr(bcx_ccx(cx).tydesc_type)); let rval = cx.build.Call(bcx_ccx(cx).upcalls.shared_malloc, ~[cx.fcx.lltaskptr, llsize, tydesc]); ret rslt(cx, cx.build.PointerCast(rval, llptr_ty)); } // trans_malloc_boxed_raw: expects an unboxed type and returns a pointer to // enough space for something of that type, along with space for a reference // count; in other words, it allocates a box for something of that type. fn trans_malloc_boxed_raw(cx: &@block_ctxt, t: ty::t) -> result { // Synthesize a fake box type structurally so we have something // to measure the size of. // We synthesize two types here because we want both the type of the // pointer and the pointee. boxed_body is the type that we measure the // size of; box_ptr is the type that's converted to a TypeRef and used as // the pointer cast target in trans_raw_malloc. // The mk_int here is the space being // reserved for the refcount. let boxed_body = ty::mk_tup(bcx_tcx(cx), ~[ty::mk_int(bcx_tcx(cx)), t]); let box_ptr = ty::mk_imm_box(bcx_tcx(cx), t); let sz = size_of(cx, boxed_body); // Grab the TypeRef type of box_ptr, because that's what trans_raw_malloc // wants. let llty = type_of(bcx_ccx(cx), cx.sp, box_ptr); ret trans_raw_malloc(sz.bcx, llty, sz.val); } // trans_malloc_boxed: usefully wraps trans_malloc_box_raw; allocates a box, // initializes the reference count to 1, and pulls out the body and rc fn trans_malloc_boxed(cx: &@block_ctxt, t: ty::t) -> {bcx: @block_ctxt, box: ValueRef, body: ValueRef} { let res = trans_malloc_boxed_raw(cx, t); let box = res.val; let rc = GEPi(res.bcx, box, ~[0, abi::box_rc_field_refcnt]); res.bcx.build.Store(C_int(1), rc); let body = GEPi(res.bcx, box, ~[0, abi::box_rc_field_body]); ret {bcx: res.bcx, box: res.val, body: body}; } // Type descriptor and type glue stuff // Given a type and a field index into its corresponding type descriptor, // returns an LLVM ValueRef of that field from the tydesc, generating the // tydesc if necessary. fn field_of_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool, field: int) -> result { let ti = none[@tydesc_info]; let tydesc = get_tydesc(cx, t, escapes, ti); ret rslt(tydesc.bcx, tydesc.bcx.build.GEP(tydesc.val, ~[C_int(0), C_int(field)])); } // Given a type containing ty params, build a vector containing a ValueRef for // each of the ty params it uses (from the current frame) and a vector of the // indices of the ty params present in the type. This is used solely for // constructing derived tydescs. fn linearize_ty_params(cx: &@block_ctxt, t: &ty::t) -> {params: [uint], descs: [ValueRef]} { let param_vals: [ValueRef] = ~[]; let param_defs: [uint] = ~[]; type rr = {cx: @block_ctxt, mutable vals: [ValueRef], mutable defs: [uint]}; fn linearizer(r: @rr, t: ty::t) { alt ty::struct(bcx_tcx(r.cx), t) { ty::ty_param(pid,_) { let seen: bool = false; for d: uint in r.defs { if d == pid { seen = true; } } if !seen { r.vals += ~[r.cx.fcx.lltydescs.(pid)]; r.defs += ~[pid]; } } _ { } } } let x = @{cx: cx, mutable vals: param_vals, mutable defs: param_defs}; let f = bind linearizer(x, _); ty::walk_ty(bcx_tcx(cx), f, t); ret {params: x.defs, descs: x.vals}; } fn trans_stack_local_derived_tydesc(cx: &@block_ctxt, llsz: ValueRef, llalign: ValueRef, llroottydesc: ValueRef, llparamtydescs: ValueRef, n_params: uint) -> ValueRef { let llmyroottydesc = alloca(cx, bcx_ccx(cx).tydesc_type); // By convention, desc 0 is the root descriptor. llroottydesc = cx.build.Load(llroottydesc); cx.build.Store(llroottydesc, llmyroottydesc); // Store a pointer to the rest of the descriptors. let llfirstparam = cx.build.GEP(llparamtydescs, ~[C_int(0), C_int(0)]); store_inbounds(cx, llfirstparam, llmyroottydesc, ~[C_int(0), C_int(abi::tydesc_field_first_param)]); store_inbounds(cx, C_uint(n_params), llmyroottydesc, ~[C_int(0), C_int(abi::tydesc_field_n_params)]); store_inbounds(cx, llsz, llmyroottydesc, ~[C_int(0), C_int(abi::tydesc_field_size)]); store_inbounds(cx, llalign, llmyroottydesc, ~[C_int(0), C_int(abi::tydesc_field_align)]); ret llmyroottydesc; } fn get_derived_tydesc(cx: &@block_ctxt, t: &ty::t, escapes: bool, static_ti: &mutable option::t[@tydesc_info]) -> result { alt cx.fcx.derived_tydescs.find(t) { some(info) { // If the tydesc escapes in this context, the cached derived // tydesc also has to be one that was marked as escaping. if !(escapes && !info.escapes) { ret rslt(cx, info.lltydesc); } } none. {/* fall through */ } } bcx_ccx(cx).stats.n_derived_tydescs += 1u; let bcx = new_raw_block_ctxt(cx.fcx, cx.fcx.llderivedtydescs); let n_params: uint = ty::count_ty_params(bcx_tcx(bcx), t); let tys = linearize_ty_params(bcx, t); assert (n_params == std::ivec::len[uint](tys.params)); assert (n_params == std::ivec::len[ValueRef](tys.descs)); let root_ti = get_static_tydesc(bcx, t, tys.params); static_ti = some[@tydesc_info](root_ti); lazily_emit_all_tydesc_glue(cx, static_ti); let root = root_ti.tydesc; let sz = size_of(bcx, t); bcx = sz.bcx; let align = align_of(bcx, t); bcx = align.bcx; let v; if escapes { /* for root*/ let tydescs = alloca(bcx, T_array(T_ptr(bcx_ccx(bcx).tydesc_type), 1u + n_params)); let i = 0; let tdp = bcx.build.GEP(tydescs, ~[C_int(0), C_int(i)]); bcx.build.Store(root, tdp); i += 1; for td: ValueRef in tys.descs { let tdp = bcx.build.GEP(tydescs, ~[C_int(0), C_int(i)]); bcx.build.Store(td, tdp); i += 1; } let lltydescsptr = bcx.build.PointerCast(tydescs, T_ptr(T_ptr(bcx_ccx(bcx).tydesc_type))); let td_val = bcx.build.Call(bcx_ccx(bcx).upcalls.get_type_desc, ~[bcx.fcx.lltaskptr, C_null(T_ptr(T_nil())), sz.val, align.val, C_int(1u + n_params as int), lltydescsptr]); v = td_val; } else { let llparamtydescs = alloca(bcx, T_array(T_ptr(bcx_ccx(bcx).tydesc_type), n_params + 1u)); let i = 0; for td: ValueRef in tys.descs { let tdp = bcx.build.GEP(llparamtydescs, ~[C_int(0), C_int(i)]); bcx.build.Store(td, tdp); i += 1; } v = trans_stack_local_derived_tydesc(bcx, sz.val, align.val, root, llparamtydescs, n_params); } bcx.fcx.derived_tydescs.insert(t, {lltydesc: v, escapes: escapes}); ret rslt(cx, v); } fn get_tydesc(cx: &@block_ctxt, orig_t: &ty::t, escapes: bool, static_ti: &mutable option::t[@tydesc_info]) -> result { let t = ty::strip_cname(bcx_tcx(cx), orig_t); // Is the supplied type a type param? If so, return the passed-in tydesc. alt ty::type_param(bcx_tcx(cx), t) { some(id) { if id < std::ivec::len(cx.fcx.lltydescs) { ret rslt(cx, cx.fcx.lltydescs.(id)); } else { bcx_tcx(cx).sess.span_bug(cx.sp, "Unbound typaram in get_tydesc: " + "orig_t = " + ty_to_str(bcx_tcx(cx), orig_t) + " ty_param = " + std::uint::str(id)); } } none. {/* fall through */ } } // Does it contain a type param? If so, generate a derived tydesc. if ty::type_contains_params(bcx_tcx(cx), t) { ret get_derived_tydesc(cx, t, escapes, static_ti); } // Otherwise, generate a tydesc if necessary, and return it. let info = get_static_tydesc(cx, t, ~[]); static_ti = some[@tydesc_info](info); ret rslt(cx, info.tydesc); } fn get_static_tydesc(cx: &@block_ctxt, orig_t: &ty::t, ty_params: &[uint]) -> @tydesc_info { let t = ty::strip_cname(bcx_tcx(cx), orig_t); alt bcx_ccx(cx).tydescs.find(t) { some(info) { ret info; } none. { bcx_ccx(cx).stats.n_static_tydescs += 1u; let info = declare_tydesc(cx.fcx.lcx, cx.sp, t, ty_params); bcx_ccx(cx).tydescs.insert(t, info); ret info; } } } fn set_no_inline(f: ValueRef) { llvm::LLVMAddFunctionAttr(f, lib::llvm::LLVMNoInlineAttribute as lib::llvm::llvm::Attribute); } // Tell LLVM to emit the information necessary to unwind the stack for the // function f. fn set_uwtable(f: ValueRef) { llvm::LLVMAddFunctionAttr(f, lib::llvm::LLVMUWTableAttribute as lib::llvm::llvm::Attribute); } fn set_always_inline(f: ValueRef) { llvm::LLVMAddFunctionAttr(f, lib::llvm::LLVMAlwaysInlineAttribute as lib::llvm::llvm::Attribute); } fn set_glue_inlining(cx: &@local_ctxt, f: ValueRef, t: &ty::t) { if ty::type_is_structural(cx.ccx.tcx, t) { set_no_inline(f); } else { set_always_inline(f); } } // Generates the declaration for (but doesn't emit) a type descriptor. fn declare_tydesc(cx: &@local_ctxt, sp: &span, t: &ty::t, ty_params: &[uint]) -> @tydesc_info { log "+++ declare_tydesc " + ty_to_str(cx.ccx.tcx, t); let ccx = cx.ccx; let llsize; let llalign; if !ty::type_has_dynamic_size(ccx.tcx, t) { let llty = type_of(ccx, sp, t); llsize = llsize_of(llty); llalign = llalign_of(llty); } else { // These will be overwritten as the derived tydesc is generated, so // we create placeholder values. llsize = C_int(0); llalign = C_int(0); } let name; if cx.ccx.sess.get_opts().debuginfo { name = mangle_internal_name_by_type_only(cx.ccx, t, "tydesc"); name = sanitize(name); } else { name = mangle_internal_name_by_seq(cx.ccx, "tydesc"); } let gvar = llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type, str::buf(name)); let info = @{ty: t, tydesc: gvar, size: llsize, align: llalign, mutable copy_glue: none[ValueRef], mutable drop_glue: none[ValueRef], mutable free_glue: none[ValueRef], mutable cmp_glue: none[ValueRef], ty_params: ty_params}; log "--- declare_tydesc " + ty_to_str(cx.ccx.tcx, t); ret info; } type make_generic_glue_helper_fn = fn(&@block_ctxt, ValueRef, &ty::t); fn declare_generic_glue(cx: &@local_ctxt, t: &ty::t, llfnty: TypeRef, name: &str) -> ValueRef { let fn_nm; if cx.ccx.sess.get_opts().debuginfo { fn_nm = mangle_internal_name_by_type_only(cx.ccx, t, "glue_" + name); fn_nm = sanitize(fn_nm); } else { fn_nm = mangle_internal_name_by_seq(cx.ccx, "glue_" + name); } let llfn = decl_cdecl_fn(cx.ccx.llmod, fn_nm, llfnty); set_glue_inlining(cx, llfn, t); ret llfn; } fn make_generic_glue_inner(cx: &@local_ctxt, sp: &span, t: &ty::t, llfn: ValueRef, helper: &make_generic_glue_helper_fn, ty_params: &[uint]) -> ValueRef { let fcx = new_fn_ctxt(cx, sp, llfn); llvm::LLVMSetLinkage(llfn, lib::llvm::LLVMInternalLinkage as llvm::Linkage); cx.ccx.stats.n_glues_created += 1u; // Any nontrivial glue is with values passed *by alias*; this is a // requirement since in many contexts glue is invoked indirectly and // the caller has no idea if it's dealing with something that can be // passed by value. let llty; if ty::type_has_dynamic_size(cx.ccx.tcx, t) { llty = T_ptr(T_i8()); } else { llty = T_ptr(type_of(cx.ccx, sp, t)); } let ty_param_count = std::ivec::len[uint](ty_params); let lltyparams = llvm::LLVMGetParam(llfn, 3u); let copy_args_bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs); let lltydescs = ~[mutable]; let p = 0u; while p < ty_param_count { let llparam = copy_args_bcx.build.GEP(lltyparams, ~[C_int(p as int)]); llparam = copy_args_bcx.build.Load(llparam); std::ivec::grow_set(lltydescs, ty_params.(p), 0 as ValueRef, llparam); p += 1u; } // TODO: Implement some kind of freeze operation in the standard library. let lltydescs_frozen = ~[]; for lltydesc: ValueRef in lltydescs { lltydescs_frozen += ~[lltydesc]; } fcx.lltydescs = lltydescs_frozen; let bcx = new_top_block_ctxt(fcx); let lltop = bcx.llbb; let llrawptr0 = llvm::LLVMGetParam(llfn, 4u); let llval0 = bcx.build.BitCast(llrawptr0, llty); helper(bcx, llval0, t); finish_fn(fcx, lltop); ret llfn; } fn make_generic_glue(cx: &@local_ctxt, sp: &span, t: &ty::t, llfn: ValueRef, helper: &make_generic_glue_helper_fn, ty_params: &[uint], name: &str) -> ValueRef { if !cx.ccx.sess.get_opts().stats { ret make_generic_glue_inner(cx, sp, t, llfn, helper, ty_params); } let start = time::get_time(); let llval = make_generic_glue_inner(cx, sp, t, llfn, helper, ty_params); let end = time::get_time(); log_fn_time(cx.ccx, "glue " + name + " " + ty_to_short_str(cx.ccx.tcx, t), start, end); ret llval; } fn emit_tydescs(ccx: &@crate_ctxt) { for each pair: @{key: ty::t, val: @tydesc_info} in ccx.tydescs.items() { let glue_fn_ty = T_ptr(T_glue_fn(*ccx)); let cmp_fn_ty = T_ptr(T_cmp_glue_fn(*ccx)); let ti = pair.val; let copy_glue = alt { ti.copy_glue } { none. { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; let drop_glue = alt { ti.drop_glue } { none. { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; let free_glue = alt { ti.free_glue } { none. { ccx.stats.n_null_glues += 1u; C_null(glue_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; let cmp_glue = alt { ti.cmp_glue } { none. { ccx.stats.n_null_glues += 1u; C_null(cmp_fn_ty) } some(v) { ccx.stats.n_real_glues += 1u; v } }; let shape = shape::shape_of(ccx, pair.key); let shape_tables = llvm::LLVMConstPointerCast(ccx.shape_cx.llshapetables, T_ptr(T_i8())); let tydesc = C_named_struct(ccx.tydesc_type, ~[C_null(T_ptr(T_ptr(ccx.tydesc_type))), ti.size, // size ti.align, // align copy_glue, // copy_glue drop_glue, // drop_glue free_glue, // free_glue C_null(glue_fn_ty), // sever_glue C_null(glue_fn_ty), // mark_glue C_null(glue_fn_ty), // obj_drop_glue C_null(glue_fn_ty), // is_stateful cmp_glue, // cmp_glue C_shape(ccx, shape), // shape shape_tables, // shape_tables C_int(0)]); // n_params let gvar = ti.tydesc; llvm::LLVMSetInitializer(gvar, tydesc); llvm::LLVMSetGlobalConstant(gvar, True); llvm::LLVMSetLinkage(gvar, lib::llvm::LLVMInternalLinkage as llvm::Linkage); } } fn make_copy_glue(cx: &@block_ctxt, v: ValueRef, t: &ty::t) { // NB: v is an *alias* of type t here, not a direct value. let bcx; if ty::type_is_task(bcx_tcx(cx), t) { let task_ptr = cx.build.Load(v); cx.build.Call(bcx_ccx(cx).upcalls.take_task, ~[cx.fcx.lltaskptr, task_ptr]); bcx = cx; } else if ty::type_is_chan(bcx_tcx(cx), t) { let ptr = cx.build.Load(v); ptr = cx.build.PointerCast(ptr, T_opaque_chan_ptr()); cx.build.Call(bcx_ccx(cx).upcalls.take_chan, ~[cx.fcx.lltaskptr, ptr]); bcx = cx; } else if ty::type_is_boxed(bcx_tcx(cx), t) { bcx = incr_refcnt_of_boxed(cx, cx.build.Load(v)).bcx; } else if (ty::type_is_structural(bcx_tcx(cx), t)) { bcx = duplicate_heap_parts_if_necessary(cx, v, t).bcx; bcx = iter_structural_ty(bcx, v, t, bind copy_ty(_, _, _)).bcx; } else { bcx = cx; } bcx.build.RetVoid(); } fn incr_refcnt_of_boxed(cx: &@block_ctxt, box_ptr: ValueRef) -> result { let rc_ptr = cx.build.GEP(box_ptr, ~[C_int(0), C_int(abi::box_rc_field_refcnt)]); let rc = cx.build.Load(rc_ptr); let rc_adj_cx = new_sub_block_ctxt(cx, "rc++"); let next_cx = new_sub_block_ctxt(cx, "next"); let const_test = cx.build.ICmp(lib::llvm::LLVMIntEQ, C_int(abi::const_refcount as int), rc); cx.build.CondBr(const_test, next_cx.llbb, rc_adj_cx.llbb); rc = rc_adj_cx.build.Add(rc, C_int(1)); rc_adj_cx.build.Store(rc, rc_ptr); rc_adj_cx.build.Br(next_cx.llbb); ret rslt(next_cx, C_nil()); } fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) { // NB: v is an *alias* of type t here, not a direct value. // FIXME: switch gc/non-gc on layer of the type. // FIXME: switch gc/non-gc on layer of the type. // TODO: call upcall_kill // Call through the obj's own fields-drop glue first. // Then free the body. // FIXME: switch gc/non-gc on layer of the type. // Call through the closure's own fields-drop glue first. // Then free the body. // FIXME: switch gc/non-gc on layer of the type. let rs = alt ty::struct(bcx_tcx(cx), t) { ty::ty_str. { let v = cx.build.Load(v0); if !bcx_ccx(cx).sess.get_opts().do_gc { trans_non_gc_free(cx, v) } else { rslt(cx, C_nil()) } } ty::ty_vec(_) { let v = cx.build.Load(v0); let rs = iter_sequence(cx, v, t, bind drop_ty(_, _, _)); if !bcx_ccx(cx).sess.get_opts().do_gc { trans_non_gc_free(rs.bcx, v) } else { rslt(cx, C_nil()) } } ty::ty_box(body_mt) { let v = cx.build.Load(v0); let body = cx.build.GEP(v, ~[C_int(0), C_int(abi::box_rc_field_body)]); let body_ty = body_mt.ty; let body_val = load_if_immediate(cx, body, body_ty); let rs = drop_ty(cx, body_val, body_ty); if !bcx_ccx(cx).sess.get_opts().do_gc { trans_non_gc_free(rs.bcx, v) } else { rslt(cx, C_nil()) } } ty::ty_uniq(_) { fail "free uniq unimplemented"; } ty::ty_port(_) { let v = cx.build.Load(v0); cx.build.Call(bcx_ccx(cx).upcalls.del_port, ~[cx.fcx.lltaskptr, cx.build.PointerCast(v, T_opaque_port_ptr())]); rslt(cx, C_int(0)) } ty::ty_chan(_) { let v = cx.build.Load(v0); cx.build.Call(bcx_ccx(cx).upcalls.del_chan, ~[cx.fcx.lltaskptr, cx.build.PointerCast(v, T_opaque_chan_ptr())]); rslt(cx, C_int(0)) } ty::ty_task. { rslt(cx, C_nil()) } ty::ty_obj(_) { let box_cell = cx.build.GEP(v0, ~[C_int(0), C_int(abi::obj_field_box)]); let b = cx.build.Load(box_cell); let ccx = bcx_ccx(cx); let llbox_ty = T_opaque_obj_ptr(*ccx); b = cx.build.PointerCast(b, llbox_ty); let body = cx.build.GEP(b, ~[C_int(0), C_int(abi::box_rc_field_body)]); let tydescptr = cx.build.GEP(body, ~[C_int(0), C_int(abi::obj_body_elt_tydesc)]); let tydesc = cx.build.Load(tydescptr); let ti = none[@tydesc_info]; call_tydesc_glue_full(cx, body, tydesc, abi::tydesc_field_drop_glue, ti); if (!bcx_ccx(cx).sess.get_opts().do_gc) { trans_non_gc_free(cx, b) } else { rslt(cx, C_nil()) } } ty::ty_fn(_, _, _, _, _) { let box_cell = cx.build.GEP(v0, ~[C_int(0), C_int(abi::fn_field_box)]); let v = cx.build.Load(box_cell); let body = cx.build.GEP(v, ~[C_int(0), C_int(abi::box_rc_field_body)]); let bindings = cx.build.GEP(body, ~[C_int(0), C_int(abi::closure_elt_bindings)]); let tydescptr = cx.build.GEP(body, ~[C_int(0), C_int(abi::closure_elt_tydesc)]); let ti = none[@tydesc_info]; call_tydesc_glue_full(cx, bindings, cx.build.Load(tydescptr), abi::tydesc_field_drop_glue, ti); if (!bcx_ccx(cx).sess.get_opts().do_gc) { trans_non_gc_free(cx, v) } else { rslt(cx, C_nil()) } } _ { rslt(cx, C_nil()) } }; rs.bcx.build.RetVoid(); } fn maybe_free_ivec_heap_part(cx: &@block_ctxt, v0: ValueRef, unit_ty: ty::t) -> result { let llunitty = type_of_or_i8(cx, unit_ty); let stack_len = cx.build.Load(cx.build.InBoundsGEP(v0, ~[C_int(0), C_uint(abi::ivec_elt_len)])); let maybe_on_heap_cx = new_sub_block_ctxt(cx, "maybe_on_heap"); let next_cx = new_sub_block_ctxt(cx, "next"); let maybe_on_heap = cx.build.ICmp(lib::llvm::LLVMIntEQ, stack_len, C_int(0)); cx.build.CondBr(maybe_on_heap, maybe_on_heap_cx.llbb, next_cx.llbb); // Might be on the heap. Load the heap pointer and free it. (It's ok to // free a null pointer.) let stub_ptr = maybe_on_heap_cx.build.PointerCast(v0, T_ptr(T_ivec_heap(llunitty))); let heap_ptr = { let v = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]; let m = maybe_on_heap_cx.build.InBoundsGEP(stub_ptr, v); maybe_on_heap_cx.build.Load(m) }; let after_free_cx = trans_shared_free(maybe_on_heap_cx, heap_ptr).bcx; after_free_cx.build.Br(next_cx.llbb); ret rslt(next_cx, C_nil()); } fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) { // NB: v0 is an *alias* of type t here, not a direct value. let ccx = bcx_ccx(cx); let rs = alt ty::struct(ccx.tcx, t) { ty::ty_str. { decr_refcnt_maybe_free(cx, v0, v0, t) } ty::ty_vec(_) { decr_refcnt_maybe_free(cx, v0, v0, t) } ty::ty_ivec(tm) { let v1; if ty::type_has_dynamic_size(ccx.tcx, tm.ty) { v1 = cx.build.PointerCast(v0, T_ptr(T_opaque_ivec())); } else { v1 = v0; } let rslt = iter_structural_ty(cx, v1, t, drop_ty); maybe_free_ivec_heap_part(rslt.bcx, v1, tm.ty) } ty::ty_box(_) { decr_refcnt_maybe_free(cx, v0, v0, t) } ty::ty_uniq(_) { fail "drop uniq unimplemented"; } ty::ty_port(_) { decr_refcnt_maybe_free(cx, v0, v0, t) } ty::ty_chan(_) { let ptr = cx.build.Load(v0); ptr = cx.build.PointerCast(ptr, T_opaque_chan_ptr()); {bcx: cx, val: cx.build.Call(bcx_ccx(cx).upcalls.drop_chan, ~[cx.fcx.lltaskptr, ptr])} } ty::ty_task. { let task_ptr = cx.build.Load(v0); {bcx: cx, val: cx.build.Call(bcx_ccx(cx).upcalls.drop_task, ~[cx.fcx.lltaskptr, task_ptr])} } ty::ty_obj(_) { let box_cell = cx.build.GEP(v0, ~[C_int(0), C_int(abi::obj_field_box)]); decr_refcnt_maybe_free(cx, box_cell, v0, t) } ty::ty_res(did, inner, tps) { trans_res_drop(cx, v0, did, inner, tps) } ty::ty_fn(_, _, _, _, _) { let box_cell = cx.build.GEP(v0, ~[C_int(0), C_int(abi::fn_field_box)]); decr_refcnt_maybe_free(cx, box_cell, v0, t) } _ { if ty::type_has_pointers(ccx.tcx, t) && ty::type_is_structural(ccx.tcx, t) { iter_structural_ty(cx, v0, t, bind drop_ty(_, _, _)) } else { rslt(cx, C_nil()) } } }; rs.bcx.build.RetVoid(); } fn trans_res_drop(cx: @block_ctxt, rs: ValueRef, did: &ast::def_id, inner_t: ty::t, tps: &[ty::t]) -> result { let ccx = bcx_ccx(cx); let inner_t_s = ty::substitute_type_params(ccx.tcx, tps, inner_t); let tup_ty = ty::mk_tup(ccx.tcx, ~[ty::mk_int(ccx.tcx), inner_t_s]); let drop_cx = new_sub_block_ctxt(cx, "drop res"); let next_cx = new_sub_block_ctxt(cx, "next"); let drop_flag = GEP_tup_like(cx, tup_ty, rs, ~[0, 0]); cx = drop_flag.bcx; let null_test = cx.build.IsNull(cx.build.Load(drop_flag.val)); cx.build.CondBr(null_test, next_cx.llbb, drop_cx.llbb); cx = drop_cx; let val = GEP_tup_like(cx, tup_ty, rs, ~[0, 1]); cx = val.bcx; // Find and call the actual destructor. let dtor_pair = trans_common::get_res_dtor(ccx, cx.sp, did, inner_t); let dtor_addr = cx.build.Load(cx.build.GEP(dtor_pair, ~[C_int(0), C_int(abi::fn_field_code)])); let dtor_env = cx.build.Load(cx.build.GEP(dtor_pair, ~[C_int(0), C_int(abi::fn_field_box)])); let args = ~[cx.fcx.llretptr, cx.fcx.lltaskptr, dtor_env]; for tp: ty::t in tps { let ti: option::t[@tydesc_info] = none; let td = get_tydesc(cx, tp, false, ti); args += ~[td.val]; cx = td.bcx; } // Kludge to work around the fact that we know the precise type of the // value here, but the dtor expects a type that still has opaque pointers // for type variables. let val_llty = lib::llvm::fn_ty_param_tys(llvm::LLVMGetElementType (llvm::LLVMTypeOf(dtor_addr))) .(std::ivec::len(args)); let val_cast = cx.build.BitCast(val.val, val_llty); cx.build.FastCall(dtor_addr, args + ~[val_cast]); cx = drop_slot(cx, val.val, inner_t_s).bcx; cx.build.Store(C_int(0), drop_flag.val); cx.build.Br(next_cx.llbb); ret rslt(next_cx, C_nil()); } fn decr_refcnt_maybe_free(cx: &@block_ctxt, box_ptr_alias: ValueRef, full_alias: ValueRef, t: &ty::t) -> result { let ccx = bcx_ccx(cx); let load_rc_cx = new_sub_block_ctxt(cx, "load rc"); let rc_adj_cx = new_sub_block_ctxt(cx, "rc--"); let free_cx = new_sub_block_ctxt(cx, "free"); let next_cx = new_sub_block_ctxt(cx, "next"); let box_ptr = cx.build.Load(box_ptr_alias); let llbox_ty = T_opaque_obj_ptr(*ccx); box_ptr = cx.build.PointerCast(box_ptr, llbox_ty); let null_test = cx.build.IsNull(box_ptr); cx.build.CondBr(null_test, next_cx.llbb, load_rc_cx.llbb); let rc_ptr = load_rc_cx.build.GEP(box_ptr, ~[C_int(0), C_int(abi::box_rc_field_refcnt)]); let rc = load_rc_cx.build.Load(rc_ptr); let const_test = load_rc_cx.build.ICmp(lib::llvm::LLVMIntEQ, C_int(abi::const_refcount as int), rc); load_rc_cx.build.CondBr(const_test, next_cx.llbb, rc_adj_cx.llbb); rc = rc_adj_cx.build.Sub(rc, C_int(1)); rc_adj_cx.build.Store(rc, rc_ptr); let zero_test = rc_adj_cx.build.ICmp(lib::llvm::LLVMIntEQ, C_int(0), rc); rc_adj_cx.build.CondBr(zero_test, free_cx.llbb, next_cx.llbb); let free_res = free_ty(free_cx, load_if_immediate(free_cx, full_alias, t), t); free_res.bcx.build.Br(next_cx.llbb); let t_else = T_nil(); let v_else = C_nil(); let phi = next_cx.build.Phi(t_else, ~[v_else, v_else, v_else, free_res.val], ~[cx.llbb, load_rc_cx.llbb, rc_adj_cx.llbb, free_res.bcx.llbb]); ret rslt(next_cx, phi); } // Structural comparison: a rather involved form of glue. fn maybe_name_value(cx: &@crate_ctxt, v: ValueRef, s: &str) { if cx.sess.get_opts().save_temps { llvm::LLVMSetValueName(v, str::buf(s)); } } // Used only for creating scalar comparison glue. tag scalar_type { nil_type; signed_int; unsigned_int; floating_point; } fn compare_scalar_types(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, t: &ty::t, llop: ValueRef) -> result { let f = bind compare_scalar_values(cx, lhs, rhs, _, llop); alt ty::struct(bcx_tcx(cx), t) { ty::ty_nil. { ret f(nil_type); } ty::ty_bool. | ty::ty_uint. | ty::ty_ptr(_) | ty::ty_char. { ret f(unsigned_int); } ty::ty_int. { ret f(signed_int); } ty::ty_float. { ret f(floating_point); } ty::ty_machine(_) { if ty::type_is_fp(bcx_tcx(cx), t) { // Floating point machine types ret f(floating_point); } else if (ty::type_is_signed(bcx_tcx(cx), t)) { // Signed, integral machine types ret f(signed_int); } else { // Unsigned, integral machine types ret f(unsigned_int); } } ty::ty_type. { trans_fail(cx, none, "attempt to compare values of type type"); // This is a bit lame, because we return a dummy block to the // caller that's actually unreachable, but I don't think it // matters. ret rslt(new_sub_block_ctxt(cx, "after_fail_dummy"), C_bool(false)); } ty::ty_native(_) { trans_fail(cx, none[span], "attempt to compare values of type native"); ret rslt(new_sub_block_ctxt(cx, "after_fail_dummy"), C_bool(false)); } _ { // Should never get here, because t is scalar. bcx_ccx(cx).sess.bug("non-scalar type passed to \ compare_scalar_types"); } } } // A helper function to do the actual comparison of scalar values. fn compare_scalar_values(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, nt: scalar_type, llop: ValueRef) -> result { let eq_cmp; let lt_cmp; let le_cmp; alt nt { nil_type. { // We don't need to do actual comparisons for nil. // () == () holds but () < () does not. eq_cmp = 1u; lt_cmp = 0u; le_cmp = 1u; } floating_point. { eq_cmp = lib::llvm::LLVMRealUEQ; lt_cmp = lib::llvm::LLVMRealULT; le_cmp = lib::llvm::LLVMRealULE; } signed_int. { eq_cmp = lib::llvm::LLVMIntEQ; lt_cmp = lib::llvm::LLVMIntSLT; le_cmp = lib::llvm::LLVMIntSLE; } unsigned_int. { eq_cmp = lib::llvm::LLVMIntEQ; lt_cmp = lib::llvm::LLVMIntULT; le_cmp = lib::llvm::LLVMIntULE; } } // FIXME: This wouldn't be necessary if we could bind methods off of // objects and therefore abstract over FCmp and ICmp (issue #435). Then // we could just write, e.g., "cmp_fn = bind cx.build.FCmp(_, _, _);" in // the above, and "auto eq_result = cmp_fn(eq_cmp, lhs, rhs);" in the // below. fn generic_cmp(cx: &@block_ctxt, nt: scalar_type, op: uint, lhs: ValueRef, rhs: ValueRef) -> ValueRef { let r: ValueRef; if nt == nil_type { r = C_bool(op != 0u); } else if (nt == floating_point) { r = cx.build.FCmp(op, lhs, rhs); } else { r = cx.build.ICmp(op, lhs, rhs); } ret r; } let last_cx = new_sub_block_ctxt(cx, "last"); let eq_cx = new_sub_block_ctxt(cx, "eq"); let eq_result = generic_cmp(eq_cx, nt, eq_cmp, lhs, rhs); eq_cx.build.Br(last_cx.llbb); let lt_cx = new_sub_block_ctxt(cx, "lt"); let lt_result = generic_cmp(lt_cx, nt, lt_cmp, lhs, rhs); lt_cx.build.Br(last_cx.llbb); let le_cx = new_sub_block_ctxt(cx, "le"); let le_result = generic_cmp(le_cx, nt, le_cmp, lhs, rhs); le_cx.build.Br(last_cx.llbb); let unreach_cx = new_sub_block_ctxt(cx, "unreach"); unreach_cx.build.Unreachable(); let llswitch = cx.build.Switch(llop, unreach_cx.llbb, 3u); llvm::LLVMAddCase(llswitch, C_u8(abi::cmp_glue_op_eq), eq_cx.llbb); llvm::LLVMAddCase(llswitch, C_u8(abi::cmp_glue_op_lt), lt_cx.llbb); llvm::LLVMAddCase(llswitch, C_u8(abi::cmp_glue_op_le), le_cx.llbb); let last_result = last_cx.build.Phi(T_i1(), ~[eq_result, lt_result, le_result], ~[eq_cx.llbb, lt_cx.llbb, le_cx.llbb]); ret rslt(last_cx, last_result); } type val_pair_fn = fn(&@block_ctxt, ValueRef, ValueRef) -> result ; type val_fn = fn(&@block_ctxt, ValueRef) -> result ; type val_and_ty_fn = fn(&@block_ctxt, ValueRef, ty::t) -> result ; // Iterates through the elements of a structural type. fn iter_structural_ty(cx: &@block_ctxt, v: ValueRef, t: &ty::t, f: val_and_ty_fn) -> result { fn adaptor_fn(f: val_and_ty_fn, cx: &@block_ctxt, av: ValueRef, t: ty::t) -> result { ret f(cx, av, t); } ret iter_structural_ty_full(cx, v, t, bind adaptor_fn(f, _, _, _)); } fn load_inbounds(cx: &@block_ctxt, p: ValueRef, idxs: &[ValueRef]) -> ValueRef { ret cx.build.Load(cx.build.InBoundsGEP(p, idxs)); } fn store_inbounds(cx: &@block_ctxt, v: ValueRef, p: ValueRef, idxs: &[ValueRef]) { cx.build.Store(v, cx.build.InBoundsGEP(p, idxs)); } // This uses store and inboundsGEP, but it only doing so superficially; it's // really storing an incremented pointer to another pointer. fn incr_ptr(cx: &@block_ctxt, p: ValueRef, incr: ValueRef, pp: ValueRef) { cx.build.Store(cx.build.InBoundsGEP(p, ~[incr]), pp); } fn iter_structural_ty_full(cx: &@block_ctxt, av: ValueRef, t: &ty::t, f: &val_and_ty_fn) -> result { fn iter_boxpp(cx: @block_ctxt, box_cell: ValueRef, f: &val_and_ty_fn) -> result { let box_ptr = cx.build.Load(box_cell); let tnil = ty::mk_nil(bcx_tcx(cx)); let tbox = ty::mk_imm_box(bcx_tcx(cx), tnil); let inner_cx = new_sub_block_ctxt(cx, "iter box"); let next_cx = new_sub_block_ctxt(cx, "next"); let null_test = cx.build.IsNull(box_ptr); cx.build.CondBr(null_test, next_cx.llbb, inner_cx.llbb); let r = f(inner_cx, box_ptr, tbox); r.bcx.build.Br(next_cx.llbb); ret rslt(next_cx, C_nil()); } fn iter_ivec(bcx: @block_ctxt, av: ValueRef, unit_ty: ty::t, f: &val_and_ty_fn) -> result { // FIXME: "unimplemented rebinding existing function" workaround fn adapter(bcx: &@block_ctxt, av: ValueRef, unit_ty: ty::t, f: val_and_ty_fn) -> result { ret f(bcx, av, unit_ty); } let llunitty = type_of_or_i8(bcx, unit_ty); let rs = size_of(bcx, unit_ty); let unit_sz = rs.val; bcx = rs.bcx; let a_len_and_data = ivec::get_len_and_data(bcx, av, unit_ty); let len = a_len_and_data.len; let a_elem = a_len_and_data.data; bcx = a_len_and_data.bcx; // Calculate the last pointer address we want to handle. // TODO: Optimize this when the size of the unit type is statically // known to not use pointer casts, which tend to confuse LLVM. let a_elem_i8 = bcx.build.PointerCast(a_elem, T_ptr(T_i8())); let a_end_i8 = bcx.build.GEP(a_elem_i8, ~[len]); let a_end = bcx.build.PointerCast(a_end_i8, T_ptr(llunitty)); let dest_elem_ptr = alloca(bcx, T_ptr(llunitty)); bcx.build.Store(a_elem, dest_elem_ptr); // Now perform the iteration. let loop_header_cx = new_sub_block_ctxt(bcx, "iter_ivec_loop_header"); bcx.build.Br(loop_header_cx.llbb); let dest_elem = loop_header_cx.build.Load(dest_elem_ptr); let not_yet_at_end = loop_header_cx.build.ICmp(lib::llvm::LLVMIntULT, dest_elem, a_end); let loop_body_cx = new_sub_block_ctxt(bcx, "iter_ivec_loop_body"); let next_cx = new_sub_block_ctxt(bcx, "iter_ivec_next"); loop_header_cx.build.CondBr(not_yet_at_end, loop_body_cx.llbb, next_cx.llbb); rs = f(loop_body_cx, load_if_immediate(loop_body_cx, dest_elem, unit_ty), unit_ty); loop_body_cx = rs.bcx; let increment; if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) { increment = unit_sz; } else { increment = C_int(1); } incr_ptr(loop_body_cx, dest_elem, increment, dest_elem_ptr); loop_body_cx.build.Br(loop_header_cx.llbb); ret rslt(next_cx, C_nil()); } fn iter_variant(cx: @block_ctxt, a_tup: ValueRef, variant: &ty::variant_info, tps: &[ty::t], tid: &ast::def_id, f: &val_and_ty_fn) -> result { if std::ivec::len[ty::t](variant.args) == 0u { ret rslt(cx, C_nil()); } let fn_ty = variant.ctor_ty; let ccx = bcx_ccx(cx); alt ty::struct(ccx.tcx, fn_ty) { ty::ty_fn(_, args, _, _, _) { let j = 0; for a: ty::arg in args { let rslt = GEP_tag(cx, a_tup, tid, variant.id, tps, j); let llfldp_a = rslt.val; cx = rslt.bcx; let ty_subst = ty::substitute_type_params(ccx.tcx, tps, a.ty); let llfld_a = load_if_immediate(cx, llfldp_a, ty_subst); rslt = f(cx, llfld_a, ty_subst); cx = rslt.bcx; j += 1; } } } ret rslt(cx, C_nil()); } let r: result = rslt(cx, C_nil()); alt ty::struct(bcx_tcx(cx), t) { ty::ty_rec(fields) { let i: int = 0; for fld: ty::field in fields { r = GEP_tup_like(r.bcx, t, av, ~[0, i]); let llfld_a = r.val; r = f(r.bcx, load_if_immediate(r.bcx, llfld_a, fld.mt.ty), fld.mt.ty); i += 1; } } ty::ty_tup(args) { let i = 0; for arg in args { r = GEP_tup_like(r.bcx, t, av, ~[0, i]); let llfld_a = r.val; r = f(r.bcx, load_if_immediate(r.bcx, llfld_a, arg), arg); i += 1; } } ty::ty_res(_, inner, tps) { let tcx = bcx_tcx(cx); let inner1 = ty::substitute_type_params(tcx, tps, inner); let inner_t_s = ty::substitute_type_params(tcx, tps, inner); let tup_t = ty::mk_tup(tcx, ~[ty::mk_int(tcx), inner_t_s]); r = GEP_tup_like(r.bcx, tup_t, av, ~[0, 1]); let llfld_a = r.val; r = f(r.bcx, load_if_immediate(r.bcx, llfld_a, inner1), inner1); } ty::ty_tag(tid, tps) { let variants = ty::tag_variants(bcx_tcx(cx), tid); let n_variants = std::ivec::len(variants); // Cast the tags to types we can GEP into. if n_variants == 1u { ret iter_variant(cx, av, variants.(0), tps, tid, f); } let lltagty = T_opaque_tag_ptr(bcx_ccx(cx).tn); let av_tag = cx.build.PointerCast(av, lltagty); let lldiscrim_a_ptr = cx.build.GEP(av_tag, ~[C_int(0), C_int(0)]); let llunion_a_ptr = cx.build.GEP(av_tag, ~[C_int(0), C_int(1)]); let lldiscrim_a = cx.build.Load(lldiscrim_a_ptr); // NB: we must hit the discriminant first so that structural // comparison know not to proceed when the discriminants differ. let bcx = cx; bcx = f(bcx, lldiscrim_a, ty::mk_int(bcx_tcx(cx))).bcx; let unr_cx = new_sub_block_ctxt(bcx, "tag-iter-unr"); unr_cx.build.Unreachable(); let llswitch = bcx.build.Switch(lldiscrim_a, unr_cx.llbb, n_variants); let next_cx = new_sub_block_ctxt(bcx, "tag-iter-next"); let i = 0u; for variant: ty::variant_info in variants { let variant_cx = new_sub_block_ctxt(bcx, "tag-iter-variant-" + uint::to_str(i, 10u)); llvm::LLVMAddCase(llswitch, C_int(i as int), variant_cx.llbb); variant_cx = iter_variant(variant_cx, llunion_a_ptr, variant, tps, tid, f).bcx; variant_cx.build.Br(next_cx.llbb); i += 1u; } ret rslt(next_cx, C_nil()); } ty::ty_fn(_, _, _, _, _) { let box_cell_a = cx.build.GEP(av, ~[C_int(0), C_int(abi::fn_field_box)]); ret iter_boxpp(cx, box_cell_a, f); } ty::ty_obj(_) { let box_cell_a = cx.build.GEP(av, ~[C_int(0), C_int(abi::obj_field_box)]); ret iter_boxpp(cx, box_cell_a, f); } ty::ty_ivec(unit_tm) { ret iter_ivec(cx, av, unit_tm.ty, f); } ty::ty_istr. { let unit_ty = ty::mk_mach(bcx_tcx(cx), ast::ty_u8); ret iter_ivec(cx, av, unit_ty, f); } _ { bcx_ccx(cx).sess.unimpl("type in iter_structural_ty_full"); } } ret r; } // Iterates through a pointer range, until the src* hits the src_lim*. fn iter_sequence_raw(cx: @block_ctxt, dst: ValueRef, // elt* src: ValueRef, // elt* src_lim: ValueRef, // elt* elt_sz: ValueRef, f: &val_pair_fn) -> result { let bcx = cx; let dst_int: ValueRef = vp2i(bcx, dst); let src_int: ValueRef = vp2i(bcx, src); let src_lim_int: ValueRef = vp2i(bcx, src_lim); let cond_cx = new_scope_block_ctxt(cx, "sequence-iter cond"); let body_cx = new_scope_block_ctxt(cx, "sequence-iter body"); let next_cx = new_sub_block_ctxt(cx, "next"); bcx.build.Br(cond_cx.llbb); let dst_curr: ValueRef = cond_cx.build.Phi(T_int(), ~[dst_int], ~[bcx.llbb]); let src_curr: ValueRef = cond_cx.build.Phi(T_int(), ~[src_int], ~[bcx.llbb]); let end_test = cond_cx.build.ICmp(lib::llvm::LLVMIntULT, src_curr, src_lim_int); cond_cx.build.CondBr(end_test, body_cx.llbb, next_cx.llbb); let dst_curr_ptr = vi2p(body_cx, dst_curr, T_ptr(T_i8())); let src_curr_ptr = vi2p(body_cx, src_curr, T_ptr(T_i8())); let body_res = f(body_cx, dst_curr_ptr, src_curr_ptr); body_cx = body_res.bcx; let dst_next = body_cx.build.Add(dst_curr, elt_sz); let src_next = body_cx.build.Add(src_curr, elt_sz); body_cx.build.Br(cond_cx.llbb); cond_cx.build.AddIncomingToPhi(dst_curr, ~[dst_next], ~[body_cx.llbb]); cond_cx.build.AddIncomingToPhi(src_curr, ~[src_next], ~[body_cx.llbb]); ret rslt(next_cx, C_nil()); } fn iter_sequence_inner(cx: &@block_ctxt, src: ValueRef, src_lim: // elt* ValueRef, elt_ty: & // elt* ty::t, f: &val_and_ty_fn) -> result { fn adaptor_fn(f: val_and_ty_fn, elt_ty: ty::t, cx: &@block_ctxt, dst: ValueRef, src: ValueRef) -> result { let llptrty; if !ty::type_has_dynamic_size(bcx_tcx(cx), elt_ty) { let llty = type_of(bcx_ccx(cx), cx.sp, elt_ty); llptrty = T_ptr(llty); } else { llptrty = T_ptr(T_ptr(T_i8())); } let p = cx.build.PointerCast(src, llptrty); ret f(cx, load_if_immediate(cx, p, elt_ty), elt_ty); } let elt_sz = size_of(cx, elt_ty); ret iter_sequence_raw(elt_sz.bcx, src, src, src_lim, elt_sz.val, bind adaptor_fn(f, elt_ty, _, _, _)); } // Iterates through the elements of a vec or str. fn iter_sequence(cx: @block_ctxt, v: ValueRef, t: &ty::t, f: &val_and_ty_fn) -> result { fn iter_sequence_body(cx: @block_ctxt, v: ValueRef, elt_ty: &ty::t, f: &val_and_ty_fn, trailing_null: bool, interior: bool) -> result { let p0; let len; let bcx; if !interior { p0 = cx.build.GEP(v, ~[C_int(0), C_int(abi::vec_elt_data)]); let lp = cx.build.GEP(v, ~[C_int(0), C_int(abi::vec_elt_fill)]); len = cx.build.Load(lp); bcx = cx; } else { let len_and_data_rslt = ivec::get_len_and_data(cx, v, elt_ty); len = len_and_data_rslt.len; p0 = len_and_data_rslt.data; bcx = len_and_data_rslt.bcx; } let llunit_ty = type_of_or_i8(cx, elt_ty); if trailing_null { let unit_sz = size_of(bcx, elt_ty); bcx = unit_sz.bcx; len = bcx.build.Sub(len, unit_sz.val); } let p1 = vi2p(bcx, bcx.build.Add(vp2i(bcx, p0), len), T_ptr(llunit_ty)); ret iter_sequence_inner(bcx, p0, p1, elt_ty, f); } alt ty::struct(bcx_tcx(cx), t) { ty::ty_vec(elt) { ret iter_sequence_body(cx, v, elt.ty, f, false, false); } ty::ty_str. { let et = ty::mk_mach(bcx_tcx(cx), ast::ty_u8); ret iter_sequence_body(cx, v, et, f, true, false); } ty::ty_ivec(elt) { ret iter_sequence_body(cx, v, elt.ty, f, false, true); } ty::ty_istr. { let et = ty::mk_mach(bcx_tcx(cx), ast::ty_u8); ret iter_sequence_body(cx, v, et, f, true, true); } _ { bcx_ccx(cx).sess.bug("unexpected type in \ trans::iter_sequence: " + ty_to_str(cx.fcx.lcx.ccx.tcx, t)); } } } fn lazily_emit_all_tydesc_glue(cx: &@block_ctxt, static_ti: &option::t[@tydesc_info]) { lazily_emit_tydesc_glue(cx, abi::tydesc_field_copy_glue, static_ti); lazily_emit_tydesc_glue(cx, abi::tydesc_field_drop_glue, static_ti); lazily_emit_tydesc_glue(cx, abi::tydesc_field_free_glue, static_ti); lazily_emit_tydesc_glue(cx, abi::tydesc_field_cmp_glue, static_ti); } fn lazily_emit_all_generic_info_tydesc_glues(cx: &@block_ctxt, gi: &generic_info) { for ti: option::t[@tydesc_info] in gi.static_tis { lazily_emit_all_tydesc_glue(cx, ti); } } fn lazily_emit_tydesc_glue(cx: &@block_ctxt, field: int, static_ti: &option::t[@tydesc_info]) { alt static_ti { none. { } some(ti) { if field == abi::tydesc_field_copy_glue { alt { ti.copy_glue } { some(_) { } none. { log #fmt("+++ lazily_emit_tydesc_glue TAKE %s", ty_to_str(bcx_tcx(cx), ti.ty)); let lcx = cx.fcx.lcx; let glue_fn = declare_generic_glue(lcx, ti.ty, T_glue_fn(*lcx.ccx), "copy"); ti.copy_glue = some[ValueRef](glue_fn); make_generic_glue(lcx, cx.sp, ti.ty, glue_fn, make_copy_glue, ti.ty_params, "take"); log #fmt("--- lazily_emit_tydesc_glue TAKE %s", ty_to_str(bcx_tcx(cx), ti.ty)); } } } else if (field == abi::tydesc_field_drop_glue) { alt { ti.drop_glue } { some(_) { } none. { log #fmt("+++ lazily_emit_tydesc_glue DROP %s", ty_to_str(bcx_tcx(cx), ti.ty)); let lcx = cx.fcx.lcx; let glue_fn = declare_generic_glue(lcx, ti.ty, T_glue_fn(*lcx.ccx), "drop"); ti.drop_glue = some[ValueRef](glue_fn); make_generic_glue(lcx, cx.sp, ti.ty, glue_fn, make_drop_glue, ti.ty_params, "drop"); log #fmt("--- lazily_emit_tydesc_glue DROP %s", ty_to_str(bcx_tcx(cx), ti.ty)); } } } else if (field == abi::tydesc_field_free_glue) { alt { ti.free_glue } { some(_) { } none. { log #fmt("+++ lazily_emit_tydesc_glue FREE %s", ty_to_str(bcx_tcx(cx), ti.ty)); let lcx = cx.fcx.lcx; let glue_fn = declare_generic_glue(lcx, ti.ty, T_glue_fn(*lcx.ccx), "free"); ti.free_glue = some[ValueRef](glue_fn); make_generic_glue(lcx, cx.sp, ti.ty, glue_fn, make_free_glue, ti.ty_params, "free"); log #fmt("--- lazily_emit_tydesc_glue FREE %s", ty_to_str(bcx_tcx(cx), ti.ty)); } } } else if (field == abi::tydesc_field_cmp_glue) { alt { ti.cmp_glue } { some(_) { } none. { log #fmt("+++ lazily_emit_tydesc_glue CMP %s", ty_to_str(bcx_tcx(cx), ti.ty)); ti.cmp_glue = some(bcx_ccx(cx).upcalls.cmp_type); log #fmt("--- lazily_emit_tydesc_glue CMP %s", ty_to_str(bcx_tcx(cx), ti.ty)); } } } } } } fn call_tydesc_glue_full(cx: &@block_ctxt, v: ValueRef, tydesc: ValueRef, field: int, static_ti: &option::t[@tydesc_info]) { lazily_emit_tydesc_glue(cx, field, static_ti); let static_glue_fn = none; alt static_ti { none. {/* no-op */ } some(sti) { if field == abi::tydesc_field_copy_glue { static_glue_fn = sti.copy_glue; } else if (field == abi::tydesc_field_drop_glue) { static_glue_fn = sti.drop_glue; } else if (field == abi::tydesc_field_free_glue) { static_glue_fn = sti.free_glue; } else if (field == abi::tydesc_field_cmp_glue) { static_glue_fn = sti.cmp_glue; } } } let llrawptr = cx.build.BitCast(v, T_ptr(T_i8())); let lltydescs = cx.build.GEP(tydesc, ~[C_int(0), C_int(abi::tydesc_field_first_param)]); lltydescs = cx.build.Load(lltydescs); let llfn; alt static_glue_fn { none. { let llfnptr = cx.build.GEP(tydesc, ~[C_int(0), C_int(field)]); llfn = cx.build.Load(llfnptr); } some(sgf) { llfn = sgf; } } cx.build.Call(llfn, ~[C_null(T_ptr(T_nil())), cx.fcx.lltaskptr, C_null(T_ptr(T_nil())), lltydescs, llrawptr]); } fn call_tydesc_glue(cx: &@block_ctxt, v: ValueRef, t: &ty::t, field: int) -> result { let ti: option::t[@tydesc_info] = none[@tydesc_info]; let td = get_tydesc(cx, t, false, ti); call_tydesc_glue_full(td.bcx, spill_if_immediate(td.bcx, v, t), td.val, field, ti); ret rslt(td.bcx, C_nil()); } fn call_cmp_glue(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, t: &ty::t, llop: ValueRef) -> result { // We can't use call_tydesc_glue_full() and friends here because compare // glue has a special signature. let lllhs = spill_if_immediate(cx, lhs, t); let llrhs = spill_if_immediate(cx, rhs, t); let llrawlhsptr = cx.build.BitCast(lllhs, T_ptr(T_i8())); let llrawrhsptr = cx.build.BitCast(llrhs, T_ptr(T_i8())); let ti = none[@tydesc_info]; let r = get_tydesc(cx, t, false, ti); lazily_emit_tydesc_glue(cx, abi::tydesc_field_cmp_glue, ti); let lltydesc = r.val; let lltydescs = r.bcx.build.GEP(lltydesc, ~[C_int(0), C_int(abi::tydesc_field_first_param)]); lltydescs = r.bcx.build.Load(lltydescs); let llfn; alt ti { none. { let llfnptr = r.bcx.build.GEP(lltydesc, ~[C_int(0), C_int(abi::tydesc_field_cmp_glue)]); llfn = r.bcx.build.Load(llfnptr); } some(sti) { llfn = option::get(sti.cmp_glue); } } let llcmpresultptr = alloca(r.bcx, T_i1()); let llargs: [ValueRef] = ~[llcmpresultptr, r.bcx.fcx.lltaskptr, lltydesc, lltydescs, llrawlhsptr, llrawrhsptr, llop]; r.bcx.build.Call(llfn, llargs); ret rslt(r.bcx, r.bcx.build.Load(llcmpresultptr)); } // Compares two values. Performs the simple scalar comparison if the types are // scalar and calls to comparison glue otherwise. fn compare(cx: &@block_ctxt, lhs: ValueRef, rhs: ValueRef, t: &ty::t, llop: ValueRef) -> result { if ty::type_is_scalar(bcx_tcx(cx), t) { ret compare_scalar_types(cx, lhs, rhs, t, llop); } ret call_cmp_glue(cx, lhs, rhs, t, llop); } fn copy_ty(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> result { if ty::type_has_pointers(bcx_tcx(cx), t) || ty::type_owns_heap_mem(bcx_tcx(cx), t) { ret call_tydesc_glue(cx, v, t, abi::tydesc_field_copy_glue); } ret rslt(cx, C_nil()); } fn drop_slot(cx: &@block_ctxt, slot: ValueRef, t: &ty::t) -> result { let llptr = load_if_immediate(cx, slot, t); ret drop_ty(cx, llptr, t); } fn drop_ty(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> result { if ty::type_needs_drop(bcx_tcx(cx), t) { ret call_tydesc_glue(cx, v, t, abi::tydesc_field_drop_glue); } ret rslt(cx, C_nil()); } fn free_ty(cx: &@block_ctxt, v: ValueRef, t: ty::t) -> result { if ty::type_has_pointers(bcx_tcx(cx), t) { ret call_tydesc_glue(cx, v, t, abi::tydesc_field_free_glue); } ret rslt(cx, C_nil()); } fn call_memmove(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, n_bytes: ValueRef) -> result { // FIXME: switch to the 64-bit variant when on such a platform. // TODO: Provide LLVM with better alignment information when the alignment // is statically known (it must be nothing more than a constant int, or // LLVM complains -- not even a constant element of a tydesc works). let i = bcx_ccx(cx).intrinsics; assert (i.contains_key("llvm.memmove.p0i8.p0i8.i32")); let memmove = i.get("llvm.memmove.p0i8.p0i8.i32"); let src_ptr = cx.build.PointerCast(src, T_ptr(T_i8())); let dst_ptr = cx.build.PointerCast(dst, T_ptr(T_i8())); let size = cx.build.IntCast(n_bytes, T_i32()); let align = C_int(1); let volatile = C_bool(false); ret rslt(cx, cx.build.Call(memmove, ~[dst_ptr, src_ptr, size, align, volatile])); } fn call_bzero(cx: &@block_ctxt, dst: ValueRef, n_bytes: ValueRef, align_bytes: ValueRef) -> result { // FIXME: switch to the 64-bit variant when on such a platform. let i = bcx_ccx(cx).intrinsics; assert (i.contains_key("llvm.memset.p0i8.i32")); let memset = i.get("llvm.memset.p0i8.i32"); let dst_ptr = cx.build.PointerCast(dst, T_ptr(T_i8())); let size = cx.build.IntCast(n_bytes, T_i32()); let align = if lib::llvm::llvm::LLVMIsConstant(align_bytes) == True { cx.build.IntCast(align_bytes, T_i32()) } else { cx.build.IntCast(C_int(0), T_i32()) }; let volatile = C_bool(false); ret rslt(cx, cx.build.Call(memset, ~[dst_ptr, C_u8(0u), size, align, volatile])); } fn memmove_ty(cx: &@block_ctxt, dst: ValueRef, src: ValueRef, t: &ty::t) -> result { if ty::type_has_dynamic_size(bcx_tcx(cx), t) { let llsz = size_of(cx, t); ret call_memmove(llsz.bcx, dst, src, llsz.val); } else if ty::type_is_structural(bcx_tcx(cx), t) { let llsz = llsize_of(type_of(bcx_ccx(cx), cx.sp, t)); ret call_memmove(cx, dst, src, llsz); } else { ret rslt(cx, cx.build.Store(cx.build.Load(src), dst)); } } // Duplicates any heap-owned memory owned by a value of the given type. fn duplicate_heap_parts_if_necessary(cx: &@block_ctxt, vptr: ValueRef, typ: ty::t) -> result { alt ty::struct(bcx_tcx(cx), typ) { ty::ty_ivec(tm) { ret ivec::duplicate_heap_part(cx, vptr, tm.ty); } ty::ty_istr. { ret ivec::duplicate_heap_part(cx, vptr, ty::mk_mach(bcx_tcx(cx), ast::ty_u8)); } _ { ret rslt(cx, C_nil()); } } } tag copy_action { INIT; DROP_EXISTING; } fn copy_val(cx: &@block_ctxt, action: copy_action, dst: ValueRef, src: ValueRef, t: &ty::t) -> result { let ccx = bcx_ccx(cx); // FIXME this is just a clunky stopgap. we should do proper checking in an // earlier pass. if !ty::type_is_copyable(ccx.tcx, t) { ccx.sess.span_fatal(cx.sp, "Copying a non-copyable type."); } if ty::type_is_scalar(ccx.tcx, t) || ty::type_is_native(ccx.tcx, t) { ret rslt(cx, cx.build.Store(src, dst)); } else if (ty::type_is_nil(ccx.tcx, t) || ty::type_is_bot(ccx.tcx, t)) { ret rslt(cx, C_nil()); } else if (ty::type_is_boxed(ccx.tcx, t)) { let bcx; if action == DROP_EXISTING { bcx = drop_ty(cx, cx.build.Load(dst), t).bcx; } else { bcx = cx; } bcx = copy_ty(bcx, src, t).bcx; ret rslt(bcx, bcx.build.Store(src, dst)); } else if (ty::type_is_structural(ccx.tcx, t) || ty::type_has_dynamic_size(ccx.tcx, t)) { // Check for self-assignment. let do_copy_cx = new_sub_block_ctxt(cx, "do_copy"); let next_cx = new_sub_block_ctxt(cx, "next"); let self_assigning = cx.build.ICmp(lib::llvm::LLVMIntNE, cx.build.PointerCast(dst, val_ty(src)), src); cx.build.CondBr(self_assigning, do_copy_cx.llbb, next_cx.llbb); if action == DROP_EXISTING { do_copy_cx = drop_ty(do_copy_cx, dst, t).bcx; } do_copy_cx = memmove_ty(do_copy_cx, dst, src, t).bcx; do_copy_cx = copy_ty(do_copy_cx, dst, t).bcx; do_copy_cx.build.Br(next_cx.llbb); ret rslt(next_cx, C_nil()); } ccx.sess.bug("unexpected type in trans::copy_val: " + ty_to_str(ccx.tcx, t)); } // This works like copy_val, except that it deinitializes the source. // Since it needs to zero out the source, src also needs to be an lval. // FIXME: We always zero out the source. Ideally we would detect the // case where a variable is always deinitialized by block exit and thus // doesn't need to be dropped. fn move_val(cx: @block_ctxt, action: copy_action, dst: ValueRef, src: &lval_result, t: &ty::t) -> result { let src_val = src.res.val; if ty::type_is_scalar(bcx_tcx(cx), t) || ty::type_is_native(bcx_tcx(cx), t) { if src.is_mem { src_val = cx.build.Load(src_val); } cx.build.Store(src_val, dst); ret rslt(cx, C_nil()); } else if (ty::type_is_nil(bcx_tcx(cx), t) || ty::type_is_bot(bcx_tcx(cx), t)) { ret rslt(cx, C_nil()); } else if (ty::type_is_boxed(bcx_tcx(cx), t)) { if src.is_mem { src_val = cx.build.Load(src_val); } if action == DROP_EXISTING { cx = drop_ty(cx, cx.build.Load(dst), t).bcx; } cx.build.Store(src_val, dst); if src.is_mem { ret zero_alloca(cx, src.res.val, t); } else { // It must be a temporary revoke_clean(cx, src_val); ret rslt(cx, C_nil()); } } else if (ty::type_is_structural(bcx_tcx(cx), t) || ty::type_has_dynamic_size(bcx_tcx(cx), t)) { if action == DROP_EXISTING { cx = drop_ty(cx, dst, t).bcx; } cx = memmove_ty(cx, dst, src_val, t).bcx; if src.is_mem { ret zero_alloca(cx, src_val, t); } else { // Temporary value revoke_clean(cx, src_val); ret rslt(cx, C_nil()); } } bcx_ccx(cx).sess.bug("unexpected type in trans::move_val: " + ty_to_str(bcx_tcx(cx), t)); } fn move_val_if_temp(cx: @block_ctxt, action: copy_action, dst: ValueRef, src: &lval_result, t: &ty::t) -> result { // Lvals in memory are not temporaries. Copy them. if src.is_mem { ret copy_val(cx, action, dst, load_if_immediate(cx, src.res.val, t), t); } else { ret move_val(cx, action, dst, src, t); } } fn trans_lit_istr(cx: &@block_ctxt, s: str) -> result { let llstackpart = alloca(cx, T_ivec(T_i8())); let len = str::byte_len(s); let bcx; if len < 3u { // 3 because of the \0 cx.build.Store(C_uint(len + 1u), cx.build.InBoundsGEP(llstackpart, ~[C_int(0), C_int(0)])); cx.build.Store(C_int(4), cx.build.InBoundsGEP(llstackpart, ~[C_int(0), C_int(1)])); let i = 0u; while i < len { cx.build.Store(C_u8(s.(i) as uint), cx.build.InBoundsGEP(llstackpart, ~[C_int(0), C_int(2), C_uint(i)])); i += 1u; } cx.build.Store(C_u8(0u), cx.build.InBoundsGEP(llstackpart, ~[C_int(0), C_int(2), C_uint(len)])); bcx = cx; } else { let r = trans_shared_malloc(cx, T_ptr(T_ivec_heap_part(T_i8())), llsize_of(T_struct(~[T_int(), T_array(T_i8(), len + 1u)]))); bcx = r.bcx; let llheappart = r.val; bcx.build.Store(C_uint(len + 1u), bcx.build.InBoundsGEP(llheappart, ~[C_int(0), C_int(0)])); bcx.build.Store(llvm::LLVMConstString(str::buf(s), len, False), bcx.build.InBoundsGEP(llheappart, ~[C_int(0), C_int(1)])); let llspilledstackpart = bcx.build.PointerCast(llstackpart, T_ptr(T_ivec_heap(T_i8()))); bcx.build.Store(C_int(0), bcx.build.InBoundsGEP(llspilledstackpart, ~[C_int(0), C_int(0)])); bcx.build.Store(C_uint(len + 1u), bcx.build.InBoundsGEP(llspilledstackpart, ~[C_int(0), C_int(1)])); bcx.build.Store(llheappart, bcx.build.InBoundsGEP(llspilledstackpart, ~[C_int(0), C_int(2)])); } ret rslt(bcx, llstackpart); } fn trans_crate_lit(cx: &@crate_ctxt, lit: &ast::lit) -> ValueRef { alt lit.node { ast::lit_int(i) { ret C_int(i); } ast::lit_uint(u) { ret C_int(u as int); } ast::lit_mach_int(tm, i) { // FIXME: the entire handling of mach types falls apart // if target int width is larger than host, at the moment; // re-do the mach-int types using 'big' when that works. let t = T_int(); let s = True; alt tm { ast::ty_u8. { t = T_i8(); s = False; } ast::ty_u16. { t = T_i16(); s = False; } ast::ty_u32. { t = T_i32(); s = False; } ast::ty_u64. { t = T_i64(); s = False; } ast::ty_i8. { t = T_i8(); } ast::ty_i16. { t = T_i16(); } ast::ty_i32. { t = T_i32(); } ast::ty_i64. { t = T_i64(); } } ret C_integral(t, i as uint, s); } ast::lit_float(fs) { ret C_float(fs); } ast::lit_mach_float(tm, s) { let t = T_float(); alt tm { ast::ty_f32. { t = T_f32(); } ast::ty_f64. { t = T_f64(); } } ret C_floating(s, t); } ast::lit_char(c) { ret C_integral(T_char(), c as uint, False); } ast::lit_bool(b) { ret C_bool(b); } ast::lit_nil. { ret C_nil(); } ast::lit_str(s, ast::sk_rc.) { ret C_str(cx, s); } ast::lit_str(s, ast::sk_unique.) { cx.sess.span_unimpl(lit.span, "unique string in this context"); } } } fn trans_lit(cx: &@block_ctxt, lit: &ast::lit) -> result { alt lit.node { ast::lit_str(s, ast::sk_unique.) { ret trans_lit_istr(cx, s); } _ { ret rslt(cx, trans_crate_lit(bcx_ccx(cx), lit)); } } } // Converts an annotation to a type fn node_id_type(cx: &@crate_ctxt, id: ast::node_id) -> ty::t { ret ty::node_id_to_monotype(cx.tcx, id); } fn node_type(cx: &@crate_ctxt, sp: &span, id: ast::node_id) -> TypeRef { ret type_of(cx, sp, node_id_type(cx, id)); } fn trans_unary(cx: &@block_ctxt, op: ast::unop, e: &@ast::expr, id: ast::node_id) -> result { let e_ty = ty::expr_ty(bcx_tcx(cx), e); alt op { ast::not. { let sub = trans_expr(cx, e); ret rslt(sub.bcx, sub.bcx.build.Not(sub.val)); } ast::neg. { let sub = trans_expr(cx, e); if ty::struct(bcx_tcx(cx), e_ty) == ty::ty_float { ret rslt(sub.bcx, sub.bcx.build.FNeg(sub.val)); } else { ret rslt(sub.bcx, sub.bcx.build.Neg(sub.val)); } } ast::box(_) { let lv = trans_lval(cx, e); let box_ty = node_id_type(bcx_ccx(lv.res.bcx), id); let sub = trans_malloc_boxed(lv.res.bcx, e_ty); let body = sub.body; add_clean_temp(cx, sub.box, box_ty); // Cast the body type to the type of the value. This is needed to // make tags work, since tags have a different LLVM type depending // on whether they're boxed or not. if !ty::type_has_dynamic_size(bcx_tcx(cx), e_ty) { let llety = T_ptr(type_of(bcx_ccx(sub.bcx), e.span, e_ty)); body = sub.bcx.build.PointerCast(body, llety); } let res = move_val_if_temp(sub.bcx, INIT, body, lv, e_ty); ret rslt(res.bcx, sub.box); } ast::deref. { bcx_ccx(cx).sess.bug("deref expressions should have been \ translated using trans_lval(), not \ trans_unary()"); } } } fn trans_compare(cx: &@block_ctxt, op: ast::binop, lhs: ValueRef, lhs_t: ty::t, rhs: ValueRef, rhs_t: ty::t) -> result { // Determine the operation we need. let llop; alt op { ast::eq. | ast::ne. { llop = C_u8(abi::cmp_glue_op_eq); } ast::lt. | ast::ge. { llop = C_u8(abi::cmp_glue_op_lt); } ast::le. | ast::gt. { llop = C_u8(abi::cmp_glue_op_le); } } let rs = compare(cx, lhs, rhs, rhs_t, llop); // Invert the result if necessary. alt op { ast::eq. | ast::lt. | ast::le. { ret rslt(rs.bcx, rs.val); } ast::ne. | ast::ge. | ast::gt. { ret rslt(rs.bcx, rs.bcx.build.Not(rs.val)); } } } fn trans_vec_append(cx: &@block_ctxt, t: &ty::t, lhs: ValueRef, rhs: ValueRef) -> result { let elt_ty = ty::sequence_element_type(bcx_tcx(cx), t); let skip_null = C_bool(false); alt ty::struct(bcx_tcx(cx), t) { ty::ty_str. { skip_null = C_bool(true); } _ { } } let bcx = cx; let ti = none[@tydesc_info]; let llvec_tydesc = get_tydesc(bcx, t, false, ti); bcx = llvec_tydesc.bcx; ti = none[@tydesc_info]; let llelt_tydesc = get_tydesc(bcx, elt_ty, false, ti); lazily_emit_tydesc_glue(cx, abi::tydesc_field_copy_glue, ti); lazily_emit_tydesc_glue(cx, abi::tydesc_field_drop_glue, ti); lazily_emit_tydesc_glue(cx, abi::tydesc_field_free_glue, ti); bcx = llelt_tydesc.bcx; let dst = bcx.build.PointerCast(lhs, T_ptr(T_opaque_vec_ptr())); let src = bcx.build.PointerCast(rhs, T_opaque_vec_ptr()); ret rslt(bcx, bcx.build.Call(bcx_ccx(cx).upcalls.vec_append, ~[cx.fcx.lltaskptr, llvec_tydesc.val, llelt_tydesc.val, dst, src, skip_null])); } mod ivec { // Returns the length of an interior vector and a pointer to its first // element, in that order. fn get_len_and_data(bcx: &@block_ctxt, orig_v: ValueRef, unit_ty: ty::t) -> {len: ValueRef, data: ValueRef, bcx: @block_ctxt} { // If this interior vector has dynamic size, we can't assume anything // about the LLVM type of the value passed in, so we cast it to an // opaque vector type. let v; if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) { v = bcx.build.PointerCast(orig_v, T_ptr(T_opaque_ivec())); } else { v = orig_v; } let llunitty = type_of_or_i8(bcx, unit_ty); let stack_len = load_inbounds(bcx, v, ~[C_int(0), C_uint(abi::ivec_elt_len)]); let stack_elem = bcx.build.InBoundsGEP(v, ~[C_int(0), C_uint(abi::ivec_elt_elems), C_int(0)]); let on_heap = bcx.build.ICmp(lib::llvm::LLVMIntEQ, stack_len, C_int(0)); let on_heap_cx = new_sub_block_ctxt(bcx, "on_heap"); let next_cx = new_sub_block_ctxt(bcx, "next"); bcx.build.CondBr(on_heap, on_heap_cx.llbb, next_cx.llbb); let heap_stub = on_heap_cx.build.PointerCast(v, T_ptr(T_ivec_heap(llunitty))); let heap_ptr = load_inbounds(on_heap_cx, heap_stub, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]); // Check whether the heap pointer is null. If it is, the vector length // is truly zero. let llstubty = T_ivec_heap(llunitty); let llheapptrty = struct_elt(llstubty, abi::ivec_heap_stub_elt_ptr); let heap_ptr_is_null = on_heap_cx.build.ICmp(lib::llvm::LLVMIntEQ, heap_ptr, C_null(T_ptr(llheapptrty))); let zero_len_cx = new_sub_block_ctxt(bcx, "zero_len"); let nonzero_len_cx = new_sub_block_ctxt(bcx, "nonzero_len"); on_heap_cx.build.CondBr(heap_ptr_is_null, zero_len_cx.llbb, nonzero_len_cx.llbb); // Technically this context is unnecessary, but it makes this function // clearer. let zero_len = C_int(0); let zero_elem = C_null(T_ptr(llunitty)); zero_len_cx.build.Br(next_cx.llbb); // If we're here, then we actually have a heapified vector. let heap_len = load_inbounds(nonzero_len_cx, heap_ptr, ~[C_int(0), C_uint(abi::ivec_heap_elt_len)]); let heap_elem = { let v = ~[C_int(0), C_uint(abi::ivec_heap_elt_elems), C_int(0)]; nonzero_len_cx.build.InBoundsGEP(heap_ptr, v) }; nonzero_len_cx.build.Br(next_cx.llbb); // Now we can figure out the length of `v` and get a pointer to its // first element. let len = next_cx.build.Phi(T_int(), ~[stack_len, zero_len, heap_len], ~[bcx.llbb, zero_len_cx.llbb, nonzero_len_cx.llbb]); let elem = next_cx.build.Phi(T_ptr(llunitty), ~[stack_elem, zero_elem, heap_elem], ~[bcx.llbb, zero_len_cx.llbb, nonzero_len_cx.llbb]); ret {len: len, data: elem, bcx: next_cx}; } // Returns a tuple consisting of a pointer to the newly-reserved space and // a block context. Updates the length appropriately. fn reserve_space(cx: &@block_ctxt, llunitty: TypeRef, v: ValueRef, len_needed: ValueRef) -> result { let stack_len_ptr = cx.build.InBoundsGEP(v, ~[C_int(0), C_uint(abi::ivec_elt_len)]); let stack_len = cx.build.Load(stack_len_ptr); let alen = load_inbounds(cx, v, ~[C_int(0), C_uint(abi::ivec_elt_alen)]); // There are four cases we have to consider: // (1) On heap, no resize necessary. // (2) On heap, need to resize. // (3) On stack, no resize necessary. // (4) On stack, need to spill to heap. let maybe_on_heap = cx.build.ICmp(lib::llvm::LLVMIntEQ, stack_len, C_int(0)); let maybe_on_heap_cx = new_sub_block_ctxt(cx, "maybe_on_heap"); let on_stack_cx = new_sub_block_ctxt(cx, "on_stack"); cx.build.CondBr(maybe_on_heap, maybe_on_heap_cx.llbb, on_stack_cx.llbb); let next_cx = new_sub_block_ctxt(cx, "next"); // We're possibly on the heap, unless the vector is zero-length. let stub_p = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]; let stub_ptr = maybe_on_heap_cx.build.PointerCast(v, T_ptr(T_ivec_heap(llunitty))); let heap_ptr = load_inbounds(maybe_on_heap_cx, stub_ptr, stub_p); let on_heap = maybe_on_heap_cx.build.ICmp(lib::llvm::LLVMIntNE, heap_ptr, C_null(val_ty(heap_ptr))); let on_heap_cx = new_sub_block_ctxt(cx, "on_heap"); maybe_on_heap_cx.build.CondBr(on_heap, on_heap_cx.llbb, on_stack_cx.llbb); // We're definitely on the heap. Check whether we need to resize. let heap_len_ptr = on_heap_cx.build.InBoundsGEP(heap_ptr, ~[C_int(0), C_uint(abi::ivec_heap_elt_len)]); let heap_len = on_heap_cx.build.Load(heap_len_ptr); let new_heap_len = on_heap_cx.build.Add(heap_len, len_needed); let heap_len_unscaled = on_heap_cx.build.UDiv(heap_len, llsize_of(llunitty)); let heap_no_resize_needed = on_heap_cx.build.ICmp(lib::llvm::LLVMIntULE, new_heap_len, alen); let heap_no_resize_cx = new_sub_block_ctxt(cx, "heap_no_resize"); let heap_resize_cx = new_sub_block_ctxt(cx, "heap_resize"); on_heap_cx.build.CondBr(heap_no_resize_needed, heap_no_resize_cx.llbb, heap_resize_cx.llbb); // Case (1): We're on the heap and don't need to resize. let heap_data_no_resize = { let v = ~[C_int(0), C_uint(abi::ivec_heap_elt_elems), heap_len_unscaled]; heap_no_resize_cx.build.InBoundsGEP(heap_ptr, v) }; heap_no_resize_cx.build.Store(new_heap_len, heap_len_ptr); heap_no_resize_cx.build.Br(next_cx.llbb); // Case (2): We're on the heap and need to resize. This path is rare, // so we delegate to cold glue. { let p = heap_resize_cx.build.PointerCast(v, T_ptr(T_opaque_ivec())); let upcall = bcx_ccx(cx).upcalls.ivec_resize_shared; heap_resize_cx.build.Call(upcall, ~[cx.fcx.lltaskptr, p, new_heap_len]); } let heap_ptr_resize = load_inbounds(heap_resize_cx, stub_ptr, stub_p); let heap_data_resize = { let v = ~[C_int(0), C_uint(abi::ivec_heap_elt_elems), heap_len_unscaled]; heap_resize_cx.build.InBoundsGEP(heap_ptr_resize, v) }; heap_resize_cx.build.Br(next_cx.llbb); // We're on the stack. Check whether we need to spill to the heap. let new_stack_len = on_stack_cx.build.Add(stack_len, len_needed); let stack_no_spill_needed = on_stack_cx.build.ICmp(lib::llvm::LLVMIntULE, new_stack_len, alen); let stack_len_unscaled = on_stack_cx.build.UDiv(stack_len, llsize_of(llunitty)); let stack_no_spill_cx = new_sub_block_ctxt(cx, "stack_no_spill"); let stack_spill_cx = new_sub_block_ctxt(cx, "stack_spill"); on_stack_cx.build.CondBr(stack_no_spill_needed, stack_no_spill_cx.llbb, stack_spill_cx.llbb); // Case (3): We're on the stack and don't need to spill. let stack_data_no_spill = stack_no_spill_cx.build.InBoundsGEP(v, ~[C_int(0), C_uint(abi::ivec_elt_elems), stack_len_unscaled]); stack_no_spill_cx.build.Store(new_stack_len, stack_len_ptr); stack_no_spill_cx.build.Br(next_cx.llbb); // Case (4): We're on the stack and need to spill. Like case (2), this // path is rare, so we delegate to cold glue. { let p = stack_spill_cx.build.PointerCast(v, T_ptr(T_opaque_ivec())); let upcall = bcx_ccx(cx).upcalls.ivec_spill_shared; stack_spill_cx.build.Call(upcall, ~[cx.fcx.lltaskptr, p, new_stack_len]); } let spill_stub = stack_spill_cx.build.PointerCast(v, T_ptr(T_ivec_heap(llunitty))); let heap_ptr_spill = load_inbounds(stack_spill_cx, spill_stub, stub_p); let heap_data_spill = { let v = ~[C_int(0), C_uint(abi::ivec_heap_elt_elems), stack_len_unscaled]; stack_spill_cx.build.InBoundsGEP(heap_ptr_spill, v) }; stack_spill_cx.build.Br(next_cx.llbb); // Phi together the different data pointers to get the result. let data_ptr = next_cx.build.Phi(T_ptr(llunitty), ~[heap_data_no_resize, heap_data_resize, stack_data_no_spill, heap_data_spill], ~[heap_no_resize_cx.llbb, heap_resize_cx.llbb, stack_no_spill_cx.llbb, stack_spill_cx.llbb]); ret rslt(next_cx, data_ptr); } fn trans_append(cx: &@block_ctxt, t: &ty::t, orig_lhs: ValueRef, orig_rhs: ValueRef) -> result { // Cast to opaque interior vector types if necessary. let lhs; let rhs; if ty::type_has_dynamic_size(bcx_tcx(cx), t) { lhs = cx.build.PointerCast(orig_lhs, T_ptr(T_opaque_ivec())); rhs = cx.build.PointerCast(orig_rhs, T_ptr(T_opaque_ivec())); } else { lhs = orig_lhs; rhs = orig_rhs; } let unit_ty = ty::sequence_element_type(bcx_tcx(cx), t); let llunitty = type_of_or_i8(cx, unit_ty); alt ty::struct(bcx_tcx(cx), t) { ty::ty_istr. { } ty::ty_ivec(_) { } _ { bcx_tcx(cx).sess.bug("non-istr/ivec in trans_append"); } } let rs = size_of(cx, unit_ty); let bcx = rs.bcx; let unit_sz = rs.val; // Gather the various type descriptors we'll need. // FIXME (issue #511): This is needed to prevent a leak. let no_tydesc_info = none; rs = get_tydesc(bcx, t, false, no_tydesc_info); bcx = rs.bcx; rs = get_tydesc(bcx, unit_ty, false, no_tydesc_info); bcx = rs.bcx; lazily_emit_tydesc_glue(bcx, abi::tydesc_field_copy_glue, none); lazily_emit_tydesc_glue(bcx, abi::tydesc_field_drop_glue, none); lazily_emit_tydesc_glue(bcx, abi::tydesc_field_free_glue, none); let rhs_len_and_data = get_len_and_data(bcx, rhs, unit_ty); let rhs_len = rhs_len_and_data.len; let rhs_data = rhs_len_and_data.data; bcx = rhs_len_and_data.bcx; rs = reserve_space(bcx, llunitty, lhs, rhs_len); let lhs_data = rs.val; bcx = rs.bcx; // Work out the end pointer. let lhs_unscaled_idx = bcx.build.UDiv(rhs_len, llsize_of(llunitty)); let lhs_end = bcx.build.InBoundsGEP(lhs_data, ~[lhs_unscaled_idx]); // Now emit the copy loop. let dest_ptr = alloca(bcx, T_ptr(llunitty)); bcx.build.Store(lhs_data, dest_ptr); let src_ptr = alloca(bcx, T_ptr(llunitty)); bcx.build.Store(rhs_data, src_ptr); let copy_loop_header_cx = new_sub_block_ctxt(bcx, "copy_loop_header"); bcx.build.Br(copy_loop_header_cx.llbb); let copy_dest_ptr = copy_loop_header_cx.build.Load(dest_ptr); let not_yet_at_end = copy_loop_header_cx.build.ICmp(lib::llvm::LLVMIntNE, copy_dest_ptr, lhs_end); let copy_loop_body_cx = new_sub_block_ctxt(bcx, "copy_loop_body"); let next_cx = new_sub_block_ctxt(bcx, "next"); copy_loop_header_cx.build.CondBr(not_yet_at_end, copy_loop_body_cx.llbb, next_cx.llbb); let copy_src_ptr = copy_loop_body_cx.build.Load(src_ptr); let copy_src = load_if_immediate(copy_loop_body_cx, copy_src_ptr, unit_ty); rs = copy_val(copy_loop_body_cx, INIT, copy_dest_ptr, copy_src, unit_ty); let post_copy_cx = rs.bcx; // Increment both pointers. if ty::type_has_dynamic_size(bcx_tcx(cx), t) { // We have to increment by the dynamically-computed size. incr_ptr(post_copy_cx, copy_dest_ptr, unit_sz, dest_ptr); incr_ptr(post_copy_cx, copy_src_ptr, unit_sz, src_ptr); } else { incr_ptr(post_copy_cx, copy_dest_ptr, C_int(1), dest_ptr); incr_ptr(post_copy_cx, copy_src_ptr, C_int(1), src_ptr); } post_copy_cx.build.Br(copy_loop_header_cx.llbb); ret rslt(next_cx, C_nil()); } type alloc_result = {bcx: @block_ctxt, llptr: ValueRef, llunitsz: ValueRef, llalen: ValueRef}; fn alloc(cx: &@block_ctxt, unit_ty: ty::t) -> alloc_result { let dynamic = ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty); let bcx; if dynamic { bcx = llderivedtydescs_block_ctxt(cx.fcx); } else { bcx = cx; } let llunitsz; let rslt = size_of(bcx, unit_ty); bcx = rslt.bcx; llunitsz = rslt.val; if dynamic { cx.fcx.llderivedtydescs = bcx.llbb; } let llalen = bcx.build.Mul(llunitsz, C_uint(abi::ivec_default_length)); let llptr; let llunitty = type_of_or_i8(bcx, unit_ty); let bcx_result; if dynamic { let llarraysz = bcx.build.Add(llsize_of(T_opaque_ivec()), llalen); let llvecptr = array_alloca(bcx, T_i8(), llarraysz); bcx_result = cx; llptr = bcx_result.build.PointerCast(llvecptr, T_ptr(T_opaque_ivec())); } else { llptr = alloca(bcx, T_ivec(llunitty)); bcx_result = bcx; } ret {bcx: bcx_result, llptr: llptr, llunitsz: llunitsz, llalen: llalen}; } fn trans_add(cx: &@block_ctxt, vec_ty: ty::t, lhs: ValueRef, rhs: ValueRef) -> result { let bcx = cx; let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty); let ares = alloc(bcx, unit_ty); bcx = ares.bcx; let llvecptr = ares.llptr; let unit_sz = ares.llunitsz; let llalen = ares.llalen; add_clean_temp(bcx, llvecptr, vec_ty); let llunitty = type_of_or_i8(bcx, unit_ty); let llheappartty = T_ivec_heap_part(llunitty); let lhs_len_and_data = get_len_and_data(bcx, lhs, unit_ty); let lhs_len = lhs_len_and_data.len; let lhs_data = lhs_len_and_data.data; bcx = lhs_len_and_data.bcx; let rhs_len_and_data = get_len_and_data(bcx, rhs, unit_ty); let rhs_len = rhs_len_and_data.len; let rhs_data = rhs_len_and_data.data; bcx = rhs_len_and_data.bcx; let lllen = bcx.build.Add(lhs_len, rhs_len); // We have three cases to handle here: // (1) Length is zero ([] + []). // (2) Copy onto stack. // (3) Allocate on heap and copy there. let len_is_zero = bcx.build.ICmp(lib::llvm::LLVMIntEQ, lllen, C_int(0)); let zero_len_cx = new_sub_block_ctxt(bcx, "zero_len"); let nonzero_len_cx = new_sub_block_ctxt(bcx, "nonzero_len"); bcx.build.CondBr(len_is_zero, zero_len_cx.llbb, nonzero_len_cx.llbb); // Case (1): Length is zero. let stub_z = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_zero)]; let stub_a = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_alen)]; let stub_p = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]; let vec_l = ~[C_int(0), C_uint(abi::ivec_elt_len)]; let vec_a = ~[C_int(0), C_uint(abi::ivec_elt_alen)]; let stub_ptr_zero = zero_len_cx.build.PointerCast(llvecptr, T_ptr(T_ivec_heap(llunitty))); zero_len_cx.build.Store(C_int(0), zero_len_cx.build.InBoundsGEP(stub_ptr_zero, stub_z)); zero_len_cx.build.Store(llalen, zero_len_cx.build.InBoundsGEP(stub_ptr_zero, stub_a)); zero_len_cx.build.Store(C_null(T_ptr(llheappartty)), zero_len_cx.build.InBoundsGEP(stub_ptr_zero, stub_p)); let next_cx = new_sub_block_ctxt(bcx, "next"); zero_len_cx.build.Br(next_cx.llbb); // Determine whether we need to spill to the heap. let on_stack = nonzero_len_cx.build.ICmp(lib::llvm::LLVMIntULE, lllen, llalen); let stack_cx = new_sub_block_ctxt(bcx, "stack"); let heap_cx = new_sub_block_ctxt(bcx, "heap"); nonzero_len_cx.build.CondBr(on_stack, stack_cx.llbb, heap_cx.llbb); // Case (2): Copy onto stack. stack_cx.build.Store(lllen, stack_cx.build.InBoundsGEP(llvecptr, vec_l)); stack_cx.build.Store(llalen, stack_cx.build.InBoundsGEP(llvecptr, vec_a)); let dest_ptr_stack = stack_cx.build.InBoundsGEP(llvecptr, ~[C_int(0), C_uint(abi::ivec_elt_elems), C_int(0)]); let copy_cx = new_sub_block_ctxt(bcx, "copy"); stack_cx.build.Br(copy_cx.llbb); // Case (3): Allocate on heap and copy there. let stub_ptr_heap = heap_cx.build.PointerCast(llvecptr, T_ptr(T_ivec_heap(llunitty))); heap_cx.build.Store(C_int(0), heap_cx.build.InBoundsGEP(stub_ptr_heap, stub_z)); heap_cx.build.Store(lllen, heap_cx.build.InBoundsGEP(stub_ptr_heap, stub_a)); let heap_sz = heap_cx.build.Add(llsize_of(llheappartty), lllen); let rs = trans_shared_malloc(heap_cx, T_ptr(llheappartty), heap_sz); let heap_part = rs.val; heap_cx = rs.bcx; heap_cx.build.Store(heap_part, heap_cx.build.InBoundsGEP(stub_ptr_heap, stub_p)); { let v = ~[C_int(0), C_uint(abi::ivec_heap_elt_len)]; heap_cx.build.Store(lllen, heap_cx.build.InBoundsGEP(heap_part, v)); } let dest_ptr_heap = heap_cx.build.InBoundsGEP(heap_part, ~[C_int(0), C_uint(abi::ivec_heap_elt_elems), C_int(0)]); heap_cx.build.Br(copy_cx.llbb); // Emit the copy loop. let first_dest_ptr = copy_cx.build.Phi(T_ptr(llunitty), ~[dest_ptr_stack, dest_ptr_heap], ~[stack_cx.llbb, heap_cx.llbb]); let lhs_end_ptr; let rhs_end_ptr; if ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty) { lhs_end_ptr = copy_cx.build.InBoundsGEP(lhs_data, ~[lhs_len]); rhs_end_ptr = copy_cx.build.InBoundsGEP(rhs_data, ~[rhs_len]); } else { let lhs_len_unscaled = copy_cx.build.UDiv(lhs_len, unit_sz); lhs_end_ptr = copy_cx.build.InBoundsGEP(lhs_data, ~[lhs_len_unscaled]); let rhs_len_unscaled = copy_cx.build.UDiv(rhs_len, unit_sz); rhs_end_ptr = copy_cx.build.InBoundsGEP(rhs_data, ~[rhs_len_unscaled]); } let dest_ptr_ptr = alloca(copy_cx, T_ptr(llunitty)); copy_cx.build.Store(first_dest_ptr, dest_ptr_ptr); let lhs_ptr_ptr = alloca(copy_cx, T_ptr(llunitty)); copy_cx.build.Store(lhs_data, lhs_ptr_ptr); let rhs_ptr_ptr = alloca(copy_cx, T_ptr(llunitty)); copy_cx.build.Store(rhs_data, rhs_ptr_ptr); let lhs_copy_cx = new_sub_block_ctxt(bcx, "lhs_copy"); copy_cx.build.Br(lhs_copy_cx.llbb); // Copy in elements from the LHS. let lhs_ptr = lhs_copy_cx.build.Load(lhs_ptr_ptr); let not_at_end_lhs = lhs_copy_cx.build.ICmp(lib::llvm::LLVMIntNE, lhs_ptr, lhs_end_ptr); let lhs_do_copy_cx = new_sub_block_ctxt(bcx, "lhs_do_copy"); let rhs_copy_cx = new_sub_block_ctxt(bcx, "rhs_copy"); lhs_copy_cx.build.CondBr(not_at_end_lhs, lhs_do_copy_cx.llbb, rhs_copy_cx.llbb); let dest_ptr_lhs_copy = lhs_do_copy_cx.build.Load(dest_ptr_ptr); let lhs_val = load_if_immediate(lhs_do_copy_cx, lhs_ptr, unit_ty); rs = copy_val(lhs_do_copy_cx, INIT, dest_ptr_lhs_copy, lhs_val, unit_ty); lhs_do_copy_cx = rs.bcx; // Increment both pointers. if ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty) { // We have to increment by the dynamically-computed size. incr_ptr(lhs_do_copy_cx, dest_ptr_lhs_copy, unit_sz, dest_ptr_ptr); incr_ptr(lhs_do_copy_cx, lhs_ptr, unit_sz, lhs_ptr_ptr); } else { incr_ptr(lhs_do_copy_cx, dest_ptr_lhs_copy, C_int(1), dest_ptr_ptr); incr_ptr(lhs_do_copy_cx, lhs_ptr, C_int(1), lhs_ptr_ptr); } lhs_do_copy_cx.build.Br(lhs_copy_cx.llbb); // Copy in elements from the RHS. let rhs_ptr = rhs_copy_cx.build.Load(rhs_ptr_ptr); let not_at_end_rhs = rhs_copy_cx.build.ICmp(lib::llvm::LLVMIntNE, rhs_ptr, rhs_end_ptr); let rhs_do_copy_cx = new_sub_block_ctxt(bcx, "rhs_do_copy"); rhs_copy_cx.build.CondBr(not_at_end_rhs, rhs_do_copy_cx.llbb, next_cx.llbb); let dest_ptr_rhs_copy = rhs_do_copy_cx.build.Load(dest_ptr_ptr); let rhs_val = load_if_immediate(rhs_do_copy_cx, rhs_ptr, unit_ty); rs = copy_val(rhs_do_copy_cx, INIT, dest_ptr_rhs_copy, rhs_val, unit_ty); rhs_do_copy_cx = rs.bcx; // Increment both pointers. if ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty) { // We have to increment by the dynamically-computed size. incr_ptr(rhs_do_copy_cx, dest_ptr_rhs_copy, unit_sz, dest_ptr_ptr); incr_ptr(rhs_do_copy_cx, rhs_ptr, unit_sz, rhs_ptr_ptr); } else { incr_ptr(rhs_do_copy_cx, dest_ptr_rhs_copy, C_int(1), dest_ptr_ptr); incr_ptr(rhs_do_copy_cx, rhs_ptr, C_int(1), rhs_ptr_ptr); } rhs_do_copy_cx.build.Br(rhs_copy_cx.llbb); // Finally done! ret rslt(next_cx, llvecptr); } // NB: This does *not* adjust reference counts. The caller must have done // this via copy_ty() beforehand. fn duplicate_heap_part(cx: &@block_ctxt, orig_vptr: ValueRef, unit_ty: ty::t) -> result { // Cast to an opaque interior vector if we can't trust the pointer // type. let vptr; if ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty) { vptr = cx.build.PointerCast(orig_vptr, T_ptr(T_opaque_ivec())); } else { vptr = orig_vptr; } let llunitty = type_of_or_i8(cx, unit_ty); let llheappartty = T_ivec_heap_part(llunitty); // Check to see if the vector is heapified. let stack_len_ptr = cx.build.InBoundsGEP(vptr, ~[C_int(0), C_uint(abi::ivec_elt_len)]); let stack_len = cx.build.Load(stack_len_ptr); let stack_len_is_zero = cx.build.ICmp(lib::llvm::LLVMIntEQ, stack_len, C_int(0)); let maybe_on_heap_cx = new_sub_block_ctxt(cx, "maybe_on_heap"); let next_cx = new_sub_block_ctxt(cx, "next"); cx.build.CondBr(stack_len_is_zero, maybe_on_heap_cx.llbb, next_cx.llbb); let stub_ptr = maybe_on_heap_cx.build.PointerCast(vptr, T_ptr(T_ivec_heap(llunitty))); let heap_ptr_ptr = maybe_on_heap_cx.build.InBoundsGEP (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]); let heap_ptr = maybe_on_heap_cx.build.Load(heap_ptr_ptr); let heap_ptr_is_nonnull = maybe_on_heap_cx.build.ICmp(lib::llvm::LLVMIntNE, heap_ptr, C_null(T_ptr(llheappartty))); let on_heap_cx = new_sub_block_ctxt(cx, "on_heap"); maybe_on_heap_cx.build.CondBr(heap_ptr_is_nonnull, on_heap_cx.llbb, next_cx.llbb); // Ok, the vector is on the heap. Copy the heap part. let alen_ptr = on_heap_cx.build.InBoundsGEP (stub_ptr, ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_alen)]); let alen = on_heap_cx.build.Load(alen_ptr); let heap_part_sz = on_heap_cx.build.Add(alen, llsize_of(T_opaque_ivec_heap_part())); let rs = trans_shared_malloc(on_heap_cx, T_ptr(llheappartty), heap_part_sz); on_heap_cx = rs.bcx; let new_heap_ptr = rs.val; rs = call_memmove(on_heap_cx, new_heap_ptr, heap_ptr, heap_part_sz); on_heap_cx = rs.bcx; on_heap_cx.build.Store(new_heap_ptr, heap_ptr_ptr); on_heap_cx.build.Br(next_cx.llbb); ret rslt(next_cx, C_nil()); } } fn trans_vec_add(cx: &@block_ctxt, t: &ty::t, lhs: ValueRef, rhs: ValueRef) -> result { let r = alloc_ty(cx, t); let tmp = r.val; r = copy_val(r.bcx, INIT, tmp, lhs, t); let bcx = trans_vec_append(r.bcx, t, tmp, rhs).bcx; tmp = load_if_immediate(bcx, tmp, t); add_clean_temp(cx, tmp, t); ret rslt(bcx, tmp); } // Important to get types for both lhs and rhs, because one might be _|_ // and the other not. fn trans_eager_binop(cx: &@block_ctxt, op: ast::binop, lhs: ValueRef, lhs_t: ty::t, rhs: ValueRef, rhs_t: ty::t) -> result { // If either is bottom, it diverges. So no need to do the // operation. if (ty::type_is_bot(bcx_tcx(cx), lhs_t) || ty::type_is_bot(bcx_tcx(cx), rhs_t)) { ret rslt(cx, cx.build.Unreachable()); } let is_float = false; let intype = lhs_t; if ty::type_is_bot(bcx_tcx(cx), intype) { intype = rhs_t; } alt ty::struct(bcx_tcx(cx), intype) { ty::ty_float. { is_float = true; } _ { is_float = false; } } alt op { ast::add. { if ty::type_is_sequence(bcx_tcx(cx), intype) { if ty::sequence_is_interior(bcx_tcx(cx), intype) { ret ivec::trans_add(cx, intype, lhs, rhs); } ret trans_vec_add(cx, intype, lhs, rhs); } if is_float { ret rslt(cx, cx.build.FAdd(lhs, rhs)); } else { ret rslt(cx, cx.build.Add(lhs, rhs)); } } ast::sub. { if is_float { ret rslt(cx, cx.build.FSub(lhs, rhs)); } else { ret rslt(cx, cx.build.Sub(lhs, rhs)); } } ast::mul. { if is_float { ret rslt(cx, cx.build.FMul(lhs, rhs)); } else { ret rslt(cx, cx.build.Mul(lhs, rhs)); } } ast::div. { if is_float { ret rslt(cx, cx.build.FDiv(lhs, rhs)); } if ty::type_is_signed(bcx_tcx(cx), intype) { ret rslt(cx, cx.build.SDiv(lhs, rhs)); } else { ret rslt(cx, cx.build.UDiv(lhs, rhs)); } } ast::rem. { if is_float { ret rslt(cx, cx.build.FRem(lhs, rhs)); } if ty::type_is_signed(bcx_tcx(cx), intype) { ret rslt(cx, cx.build.SRem(lhs, rhs)); } else { ret rslt(cx, cx.build.URem(lhs, rhs)); } } ast::bitor. { ret rslt(cx, cx.build.Or(lhs, rhs)); } ast::bitand. { ret rslt(cx, cx.build.And(lhs, rhs)); } ast::bitxor. { ret rslt(cx, cx.build.Xor(lhs, rhs)); } ast::lsl. { ret rslt(cx, cx.build.Shl(lhs, rhs)); } ast::lsr. { ret rslt(cx, cx.build.LShr(lhs, rhs)); } ast::asr. { ret rslt(cx, cx.build.AShr(lhs, rhs)); } _ { ret trans_compare(cx, op, lhs, lhs_t, rhs, rhs_t); } } } fn autoderef(cx: &@block_ctxt, v: ValueRef, t: &ty::t) -> result_t { let v1: ValueRef = v; let t1: ty::t = t; let ccx = bcx_ccx(cx); while true { alt ty::struct(ccx.tcx, t1) { ty::ty_box(mt) { let body = cx.build.GEP(v1, ~[C_int(0), C_int(abi::box_rc_field_body)]); t1 = mt.ty; // Since we're changing levels of box indirection, we may have // to cast this pointer, since statically-sized tag types have // different types depending on whether they're behind a box // or not. if !ty::type_has_dynamic_size(ccx.tcx, mt.ty) { let llty = type_of(ccx, cx.sp, mt.ty); v1 = cx.build.PointerCast(body, T_ptr(llty)); } else { v1 = body; } } ty::ty_uniq(t) { fail "autoderef uniq unimplemented"; } ty::ty_res(did, inner, tps) { t1 = ty::substitute_type_params(ccx.tcx, tps, inner); v1 = cx.build.GEP(v1, ~[C_int(0), C_int(1)]); } ty::ty_tag(did, tps) { let variants = ty::tag_variants(ccx.tcx, did); if std::ivec::len(variants) != 1u || std::ivec::len(variants.(0).args) != 1u { break; } t1 = ty::substitute_type_params(ccx.tcx, tps, variants.(0).args.(0)); if !ty::type_has_dynamic_size(ccx.tcx, t1) { v1 = cx.build.PointerCast(v1, T_ptr(type_of(ccx, cx.sp, t1))); } } _ { break; } } v1 = load_if_immediate(cx, v1, t1); } ret {bcx: cx, val: v1, ty: t1}; } fn trans_binary(cx: &@block_ctxt, op: ast::binop, a: &@ast::expr, b: &@ast::expr) -> result { // First couple cases are lazy: alt op { ast::and. { // Lazy-eval and let lhs_res = trans_expr(cx, a); let rhs_cx = new_scope_block_ctxt(cx, "rhs"); let rhs_res = trans_expr(rhs_cx, b); let lhs_false_cx = new_scope_block_ctxt(cx, "lhs false"); let lhs_false_res = rslt(lhs_false_cx, C_bool(false)); // The following line ensures that any cleanups for rhs // are done within the block for rhs. This is necessary // because and/or are lazy. So the rhs may never execute, // and the cleanups can't be pushed into later code. let rhs_bcx = trans_block_cleanups(rhs_res.bcx, rhs_cx); lhs_res.bcx.build.CondBr(lhs_res.val, rhs_cx.llbb, lhs_false_cx.llbb); ret join_results(cx, T_bool(), ~[lhs_false_res, {bcx: rhs_bcx, val: rhs_res.val}]); } ast::or. { // Lazy-eval or let lhs_res = trans_expr(cx, a); let rhs_cx = new_scope_block_ctxt(cx, "rhs"); let rhs_res = trans_expr(rhs_cx, b); let lhs_true_cx = new_scope_block_ctxt(cx, "lhs true"); let lhs_true_res = rslt(lhs_true_cx, C_bool(true)); // see the and case for an explanation let rhs_bcx = trans_block_cleanups(rhs_res.bcx, rhs_cx); lhs_res.bcx.build.CondBr(lhs_res.val, lhs_true_cx.llbb, rhs_cx.llbb); ret join_results(cx, T_bool(), ~[lhs_true_res, {bcx: rhs_bcx, val: rhs_res.val}]); } _ { // Remaining cases are eager: let lhs = trans_expr(cx, a); let rhs = trans_expr(lhs.bcx, b); ret trans_eager_binop(rhs.bcx, op, lhs.val, ty::expr_ty(bcx_tcx(cx), a), rhs.val, ty::expr_ty(bcx_tcx(cx), b)); } } } fn join_results(parent_cx: &@block_ctxt, t: TypeRef, ins: &[result]) -> result { let live: [result] = ~[]; let vals: [ValueRef] = ~[]; let bbs: [BasicBlockRef] = ~[]; for r: result in ins { if !is_terminated(r.bcx) { live += ~[r]; vals += ~[r.val]; bbs += ~[r.bcx.llbb]; } } alt std::ivec::len[result](live) { 0u { // No incoming edges are live, so we're in dead-code-land. // Arbitrarily pick the first dead edge, since the caller // is just going to propagate it outward. assert (std::ivec::len[result](ins) >= 1u); ret ins.(0); } _ {/* fall through */ } } // We have >1 incoming edges. Make a join block and br+phi them into it. let join_cx = new_sub_block_ctxt(parent_cx, "join"); for r: result in live { r.bcx.build.Br(join_cx.llbb); } let phi = join_cx.build.Phi(t, vals, bbs); ret rslt(join_cx, phi); } fn join_branches(parent_cx: &@block_ctxt, ins: &[result]) -> @block_ctxt { let out = new_sub_block_ctxt(parent_cx, "join"); for r: result in ins { if !is_terminated(r.bcx) { r.bcx.build.Br(out.llbb); } } ret out; } tag out_method { return; save_in(ValueRef); } fn trans_if(cx: &@block_ctxt, cond: &@ast::expr, thn: &ast::blk, els: &option::t[@ast::expr], id: ast::node_id, output: &out_method) -> result { let cond_res = trans_expr(cx, cond); if (ty::type_is_bot(bcx_tcx(cx), ty::expr_ty(bcx_tcx(cx), cond))) { // No need to generate code for comparison, // since the cond diverges. if (!cx.build.is_terminated()) { ret rslt(cx, cx.build.Unreachable()); } else { ret cond_res; } } let then_cx = new_scope_block_ctxt(cx, "then"); let then_res = trans_block(then_cx, thn, output); let else_cx = new_scope_block_ctxt(cx, "else"); // Synthesize a block here to act as the else block // containing an if expression. Needed in order for the // else scope to behave like a normal block scope. A tad // ugly. // Calling trans_block directly instead of trans_expr // because trans_expr will create another scope block // context for the block, but we've already got the // 'else' context let else_res = alt els { some(elexpr) { alt elexpr.node { ast::expr_if(_, _, _) { let elseif_blk = ast::block_from_expr(elexpr); trans_block(else_cx, elseif_blk, output) } ast::expr_block(blk) { trans_block(else_cx, blk, output) } } } _ { rslt(else_cx, C_nil()) } }; cond_res.bcx.build.CondBr(cond_res.val, then_cx.llbb, else_cx.llbb); ret rslt(join_branches(cx, ~[then_res, else_res]), C_nil()); } fn trans_for(cx: &@block_ctxt, local: &@ast::local, seq: &@ast::expr, body: &ast::blk) -> result { // FIXME: We bind to an alias here to avoid a segfault... this is // obviously a bug. fn inner(cx: &@block_ctxt, local: @ast::local, curr: ValueRef, t: ty::t, body: &ast::blk, outer_next_cx: @block_ctxt) -> result { let next_cx = new_sub_block_ctxt(cx, "next"); let scope_cx = new_loop_scope_block_ctxt(cx, option::some[@block_ctxt](next_cx), outer_next_cx, "for loop scope"); cx.build.Br(scope_cx.llbb); let local_res = alloc_local(scope_cx, local); let loc_r = copy_val(local_res.bcx, INIT, local_res.val, curr, t); add_clean(scope_cx, local_res.val, t); let bcx = trans_alt::bind_irrefutable_pat (loc_r.bcx, local.node.pat, local_res.val, cx.fcx.lllocals, false); bcx = trans_block(bcx, body, return).bcx; if !bcx.build.is_terminated() { bcx.build.Br(next_cx.llbb); // otherwise, this code is unreachable } ret rslt(next_cx, C_nil()); } let next_cx = new_sub_block_ctxt(cx, "next"); let seq_ty = ty::expr_ty(bcx_tcx(cx), seq); let seq_res = trans_expr(cx, seq); let it = iter_sequence(seq_res.bcx, seq_res.val, seq_ty, bind inner(_, local, _, _, body, next_cx)); it.bcx.build.Br(next_cx.llbb); ret rslt(next_cx, it.val); } // Iterator translation // Given a block context and a list of tydescs and values to bind // construct a closure out of them. If copying is true, it is a // heap allocated closure that copies the upvars into environment. // Otherwise, it is stack allocated and copies pointers to the upvars. fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef], bound_tys: [ty::t], bound_vals: [lval_result], copying: bool) -> {ptr: ValueRef, ptrty: ty::t, bcx: @block_ctxt} { // Synthesize a closure type. // First, synthesize a tuple type containing the types of all the // bound expressions. // bindings_ty = ~[bound_ty1, bound_ty2, ...] let bindings_ty: ty::t = ty::mk_tup(bcx_tcx(bcx), bound_tys); // NB: keep this in sync with T_closure_ptr; we're making // a ty::t structure that has the same "shape" as the LLVM type // it constructs. // Make a vector that contains ty_param_count copies of tydesc_ty. // (We'll need room for that many tydescs in the closure.) let ty_param_count = std::ivec::len(lltydescs); let tydesc_ty: ty::t = ty::mk_type(bcx_tcx(bcx)); let captured_tys: [ty::t] = std::ivec::init_elt(tydesc_ty, ty_param_count); // Get all the types we've got (some of which we synthesized // ourselves) into a vector. The whole things ends up looking // like: // closure_tys = [tydesc_ty, [bound_ty1, bound_ty2, ...], [tydesc_ty, // tydesc_ty, ...]] let closure_tys: [ty::t] = ~[tydesc_ty, bindings_ty, ty::mk_tup(bcx_tcx(bcx), captured_tys)]; // Finally, synthesize a type for that whole vector. let closure_ty: ty::t = ty::mk_tup(bcx_tcx(bcx), closure_tys); // Allocate a box that can hold something closure-sized. let r = if copying { trans_malloc_boxed(bcx, closure_ty) } else { // We need to dummy up a box on the stack let ty = ty::mk_tup(bcx_tcx(bcx), ~[ty::mk_int(bcx_tcx(bcx)), closure_ty]); let r = alloc_ty(bcx, ty); let body = GEPi(bcx, r.val, ~[0, abi::box_rc_field_body]); {bcx: r.bcx, box: r.val, body: body} }; bcx = r.bcx; let closure = r.body; // Store bindings tydesc. if copying { let bound_tydesc = GEPi(bcx, closure, ~[0, abi::closure_elt_tydesc]); let ti = none; let bindings_tydesc = get_tydesc(bcx, bindings_ty, true, ti); lazily_emit_tydesc_glue(bcx, abi::tydesc_field_drop_glue, ti); lazily_emit_tydesc_glue(bcx, abi::tydesc_field_free_glue, ti); bcx = bindings_tydesc.bcx; bcx.build.Store(bindings_tydesc.val, bound_tydesc); } // Copy expr values into boxed bindings. let i = 0u; let bindings = GEP_tup_like(bcx, closure_ty, closure, ~[0, abi::closure_elt_bindings]); bcx = bindings.bcx; for lv: lval_result in bound_vals { let bound = GEP_tup_like(bcx, bindings_ty, bindings.val, ~[0, i as int]); bcx = bound.bcx; if copying { bcx = move_val_if_temp(bcx, INIT, bound.val, lv, bound_tys.(i)).bcx; } else { bcx.build.Store(lv.res.val, bound.val); } i += 1u; } // If necessary, copy tydescs describing type parameters into the // appropriate slot in the closure. let ty_params_slot = GEP_tup_like(bcx, closure_ty, closure, ~[0, abi::closure_elt_ty_params]); bcx = ty_params_slot.bcx; i = 0u; for td: ValueRef in lltydescs { let ty_param_slot = GEPi(bcx, ty_params_slot.val, ~[0, i as int]); bcx.build.Store(td, ty_param_slot); i += 1u; } ret {ptr: r.box, ptrty: closure_ty, bcx: bcx}; } // Given a context and a list of upvars, build a closure. This just // collects the upvars and packages them up for build_environment. fn build_closure(cx: &@block_ctxt, upvars: &@[ast::node_id], copying: bool) -> {ptr: ValueRef, ptrty: ty::t, bcx: @block_ctxt} { let closure_vals: [lval_result] = ~[]; let closure_tys: [ty::t] = ~[]; // If we need to, package up the iterator body to call if !copying && !option::is_none(cx.fcx.lliterbody) { closure_vals += ~[lval_mem(cx, option::get(cx.fcx.lliterbody))]; closure_tys += ~[option::get(cx.fcx.iterbodyty)]; } // Package up the upvars for nid: ast::node_id in *upvars { closure_vals += ~[trans_var(cx, cx.sp, nid)]; let ty = ty::node_id_to_monotype(bcx_tcx(cx), nid); if !copying { ty = ty::mk_mut_ptr(bcx_tcx(cx), ty); } closure_tys += ~[ty]; } ret build_environment(cx, cx.fcx.lltydescs, closure_tys, closure_vals, copying); } // Return a pointer to the stored typarams in a closure. // This is awful. Since the size of the bindings stored in the closure might // be dynamically sized, we can't skip past them to get to the tydescs until // we have loaded the tydescs. Thus we use the stored size of the bindings // in the tydesc for the closure to skip over them. Ugh. fn find_environment_tydescs(bcx: &@block_ctxt, envty: &ty::t, closure: ValueRef) -> ValueRef { ret if !ty::type_has_dynamic_size(bcx_tcx(bcx), envty) { // If we can find the typarams statically, do it GEPi(bcx, closure, ~[0, abi::box_rc_field_body, abi::closure_elt_ty_params]) } else { // Ugh. We need to load the size of the bindings out of the // closure's tydesc and use that to skip over the bindings. let descsty = ty::get_element_type(bcx_tcx(bcx), envty, abi::closure_elt_ty_params as uint); let llenv = GEPi(bcx, closure, ~[0, abi::box_rc_field_body]); // Load the tydesc and find the size of the body let lldesc = bcx.build.Load(GEPi(bcx, llenv, ~[0, abi::closure_elt_tydesc])); let llsz = bcx.build.Load( GEPi(bcx, lldesc, ~[0, abi::tydesc_field_size])); // Get the bindings pointer and add the size to it let llbinds = GEPi(bcx, llenv, ~[0, abi::closure_elt_bindings]); bump_ptr(bcx, descsty, llbinds, llsz) } } // Given an enclosing block context, a new function context, a closure type, // and a list of upvars, generate code to load and populate the environment // with the upvars and type descriptors. fn load_environment(enclosing_cx: &@block_ctxt, fcx: &@fn_ctxt, envty: &ty::t, upvars: &@[ast::node_id], copying: bool) { let bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs); let ty = ty::mk_imm_box(bcx_tcx(bcx), envty); let llty = type_of(bcx_ccx(bcx), bcx.sp, ty); let llclosure = bcx.build.PointerCast(fcx.llenv, llty); // Populate the type parameters from the environment. We need to // do this first because the tydescs are needed to index into // the bindings if they are dynamically sized. let tydesc_count = std::ivec::len(enclosing_cx.fcx.lltydescs); let lltydescs = find_environment_tydescs(bcx, envty, llclosure); let i = 0u; while i < tydesc_count { let lltydescptr = GEPi(bcx, lltydescs, ~[0, i as int]); fcx.lltydescs += ~[bcx.build.Load(lltydescptr)]; i += 1u; } // Populate the upvars from the environment. let path = ~[0, abi::box_rc_field_body, abi::closure_elt_bindings]; i = 0u; // If this is an aliasing closure/for-each body, we need to load // the iterbody. if !copying && !option::is_none(enclosing_cx.fcx.lliterbody) { let iterbodyptr = GEP_tup_like(bcx, ty, llclosure, path + ~[0]); fcx.lliterbody = some(bcx.build.Load(iterbodyptr.val)); bcx = iterbodyptr.bcx; i += 1u; } // Load the acutal upvars. for upvar_id: ast::node_id in *upvars { let upvarptr = GEP_tup_like(bcx, ty, llclosure, path + ~[i as int]); bcx = upvarptr.bcx; let llupvarptr = upvarptr.val; if !copying { llupvarptr = bcx.build.Load(llupvarptr); } let def_id = ast::def_id_of_def(bcx_tcx(bcx).def_map.get(upvar_id)); fcx.llupvars.insert(def_id.node, llupvarptr); i += 1u; } } fn trans_for_each(cx: &@block_ctxt, local: &@ast::local, seq: &@ast::expr, body: &ast::blk) -> result { /* * The translation is a little .. complex here. Code like: * * let ty1 p = ...; * * let ty1 q = ...; * * foreach (ty v in foo(a,b)) { body(p,q,v) } * * * Turns into a something like so (C/Rust mishmash): * * type env = { *ty1 p, *ty2 q, ... }; * * let env e = { &p, &q, ... }; * * fn foreach123_body(env* e, ty v) { body(*(e->p),*(e->q),v) } * * foo([foreach123_body, env*], a, b); * */ // Step 1: Generate code to build an environment containing pointers // to all of the upvars let lcx = cx.fcx.lcx; // FIXME: possibly support alias-mode here? let decl_ty = node_id_type(lcx.ccx, local.node.id); let upvars = get_freevars(lcx.ccx.tcx, body.node.id); let llenv = build_closure(cx, upvars, false); // Step 2: Declare foreach body function. let s: str = mangle_internal_name_by_path_and_seq(lcx.ccx, lcx.path, "foreach"); // The 'env' arg entering the body function is a fake env member (as in // the env-part of the normal rust calling convention) that actually // points to a stack allocated env in this frame. We bundle that env // pointer along with the foreach-body-fn pointer into a 'normal' fn pair // and pass it in as a first class fn-arg to the iterator. let iter_body_llty = type_of_fn_from_ty(lcx.ccx, cx.sp, ty::mk_iter_body_fn(lcx.ccx.tcx, decl_ty), 0u); let lliterbody: ValueRef = decl_internal_fastcall_fn(lcx.ccx.llmod, s, iter_body_llty); let fcx = new_fn_ctxt_w_id(lcx, cx.sp, lliterbody, body.node.id); fcx.iterbodyty = cx.fcx.iterbodyty; // Generate code to load the environment out of the // environment pointer. load_environment(cx, fcx, llenv.ptrty, upvars, false); let bcx = new_top_block_ctxt(fcx); // Add bindings for the loop variable alias. bcx = trans_alt::bind_irrefutable_pat (bcx, local.node.pat, llvm::LLVMGetParam(fcx.llfn, 3u), bcx.fcx.lllocals, false); let lltop = bcx.llbb; let r = trans_block(bcx, body, return); finish_fn(fcx, lltop); if !r.bcx.build.is_terminated() { // if terminated is true, no need for the ret-fail r.bcx.build.RetVoid(); } // Step 3: Call iter passing [lliterbody, llenv], plus other args. alt seq.node { ast::expr_call(f, args) { let pair = create_real_fn_pair(cx, iter_body_llty, lliterbody, llenv.ptr); r = trans_call(cx, f, some[ValueRef](cx.build.Load(pair)), args, seq.id); ret rslt(r.bcx, C_nil()); } } } fn trans_while(cx: &@block_ctxt, cond: &@ast::expr, body: &ast::blk) -> result { let cond_cx = new_scope_block_ctxt(cx, "while cond"); let next_cx = new_sub_block_ctxt(cx, "next"); let body_cx = new_loop_scope_block_ctxt(cx, option::none[@block_ctxt], next_cx, "while loop body"); let body_res = trans_block(body_cx, body, return); let cond_res = trans_expr(cond_cx, cond); body_res.bcx.build.Br(cond_cx.llbb); let cond_bcx = trans_block_cleanups(cond_res.bcx, cond_cx); cond_bcx.build.CondBr(cond_res.val, body_cx.llbb, next_cx.llbb); cx.build.Br(cond_cx.llbb); ret rslt(next_cx, C_nil()); } fn trans_do_while(cx: &@block_ctxt, body: &ast::blk, cond: &@ast::expr) -> result { let next_cx = new_sub_block_ctxt(cx, "next"); let body_cx = new_loop_scope_block_ctxt(cx, option::none[@block_ctxt], next_cx, "do-while loop body"); let body_res = trans_block(body_cx, body, return); if is_terminated(body_res.bcx) { // This is kind of ridiculous, but no permutations // involving body_res or body_cx.val worked. let rs = trans_block(cx, body, return); if ! is_terminated (next_cx) { next_cx.build.Unreachable(); } if ! is_terminated (body_cx) { body_cx.build.Unreachable(); } ret rs; } let cond_res = trans_expr(body_res.bcx, cond); cond_res.bcx.build.CondBr(cond_res.val, body_cx.llbb, next_cx.llbb); cx.build.Br(body_cx.llbb); ret rslt(next_cx, body_res.val); } type generic_info = {item_type: ty::t, static_tis: [option::t[@tydesc_info]], tydescs: [ValueRef]}; type lval_result = {res: result, is_mem: bool, generic: option::t[generic_info], llobj: option::t[ValueRef], method_ty: option::t[ty::t]}; fn lval_mem(cx: &@block_ctxt, val: ValueRef) -> lval_result { ret {res: rslt(cx, val), is_mem: true, generic: none[generic_info], llobj: none[ValueRef], method_ty: none[ty::t]}; } fn lval_val(cx: &@block_ctxt, val: ValueRef) -> lval_result { ret {res: rslt(cx, val), is_mem: false, generic: none[generic_info], llobj: none[ValueRef], method_ty: none[ty::t]}; } fn trans_external_path(cx: &@block_ctxt, did: &ast::def_id, tpt: &ty::ty_param_kinds_and_ty) -> ValueRef { let lcx = cx.fcx.lcx; let name = csearch::get_symbol(lcx.ccx.sess.get_cstore(), did); ret get_extern_const(lcx.ccx.externs, lcx.ccx.llmod, name, type_of_ty_param_kinds_and_ty(lcx, cx.sp, tpt)); } fn lval_generic_fn(cx: &@block_ctxt, tpt: &ty::ty_param_kinds_and_ty, fn_id: &ast::def_id, id: ast::node_id) -> lval_result { let lv; if fn_id.crate == ast::local_crate { // Internal reference. assert (bcx_ccx(cx).fn_pairs.contains_key(fn_id.node)); lv = lval_val(cx, bcx_ccx(cx).fn_pairs.get(fn_id.node)); } else { // External reference. lv = lval_val(cx, trans_external_path(cx, fn_id, tpt)); } let tys = ty::node_id_to_type_params(bcx_tcx(cx), id); if std::ivec::len[ty::t](tys) != 0u { let bcx = lv.res.bcx; let tydescs: [ValueRef] = ~[]; let tis: [option::t[@tydesc_info]] = ~[]; for t: ty::t in tys { // TODO: Doesn't always escape. let ti = none[@tydesc_info]; let td = get_tydesc(bcx, t, true, ti); tis += ~[ti]; bcx = td.bcx; tydescs += ~[td.val]; } let gen = {item_type: tpt.ty, static_tis: tis, tydescs: tydescs}; lv = {res: rslt(bcx, lv.res.val), generic: some(gen) with lv}; } ret lv; } fn lookup_discriminant(lcx: &@local_ctxt, tid: &ast::def_id, vid: &ast::def_id) -> ValueRef { alt lcx.ccx.discrims.find(vid.node) { none. { // It's an external discriminant that we haven't seen yet. assert (vid.crate != ast::local_crate); let sym = csearch::get_symbol(lcx.ccx.sess.get_cstore(), vid); let gvar = llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), str::buf(sym)); llvm::LLVMSetLinkage(gvar, lib::llvm::LLVMExternalLinkage as llvm::Linkage); llvm::LLVMSetGlobalConstant(gvar, True); lcx.ccx.discrims.insert(vid.node, gvar); ret gvar; } some(llval) { ret llval; } } } fn trans_var(cx: &@block_ctxt, sp: &span, id: ast::node_id) -> lval_result { let ccx = bcx_ccx(cx); alt freevars::def_lookup(bcx_tcx(cx), cx.fcx.id, id) { some(ast::def_upvar(did, _)) { assert (cx.fcx.llupvars.contains_key(did.node)); ret lval_mem(cx, cx.fcx.llupvars.get(did.node)); } some(ast::def_arg(did)) { assert (cx.fcx.llargs.contains_key(did.node)); ret lval_mem(cx, cx.fcx.llargs.get(did.node)); } some(ast::def_local(did)) { assert (cx.fcx.lllocals.contains_key(did.node)); ret lval_mem(cx, cx.fcx.lllocals.get(did.node)); } some(ast::def_binding(did)) { assert (cx.fcx.lllocals.contains_key(did.node)); ret lval_mem(cx, cx.fcx.lllocals.get(did.node)); } some(ast::def_obj_field(did)) { assert (cx.fcx.llobjfields.contains_key(did.node)); ret lval_mem(cx, cx.fcx.llobjfields.get(did.node)); } some(ast::def_fn(did, _)) { let tyt = ty::lookup_item_type(ccx.tcx, did); ret lval_generic_fn(cx, tyt, did, id); } some(ast::def_variant(tid, vid)) { let v_tyt = ty::lookup_item_type(ccx.tcx, vid); alt ty::struct(ccx.tcx, v_tyt.ty) { ty::ty_fn(_, _, _, _, _) { // N-ary variant. ret lval_generic_fn(cx, v_tyt, vid, id); } _ { // Nullary variant. let tag_ty = node_id_type(ccx, id); let alloc_result = alloc_ty(cx, tag_ty); let lltagblob = alloc_result.val; let lltagty = type_of_tag(ccx, sp, tid, tag_ty); let bcx = alloc_result.bcx; let lltagptr = bcx.build.PointerCast(lltagblob, T_ptr(lltagty)); if std::ivec::len(ty::tag_variants(ccx.tcx, tid)) != 1u { let lldiscrim_gv = lookup_discriminant(bcx.fcx.lcx, tid, vid); let lldiscrim = bcx.build.Load(lldiscrim_gv); let lldiscrimptr = bcx.build.GEP(lltagptr, ~[C_int(0), C_int(0)]); bcx.build.Store(lldiscrim, lldiscrimptr); } ret lval_val(bcx, lltagptr); } } } some(ast::def_const(did)) { if did.crate == ast::local_crate { assert (ccx.consts.contains_key(did.node)); ret lval_mem(cx, ccx.consts.get(did.node)); } else { let tp = ty::node_id_to_monotype(ccx.tcx, id); let k: [ast::kind] = ~[]; ret lval_val(cx, load_if_immediate(cx, trans_external_path(cx, did, {kinds: k, ty: tp}), tp)); } } some(ast::def_native_fn(did)) { let tyt = ty::lookup_item_type(ccx.tcx, did); ret lval_generic_fn(cx, tyt, did, id); } _ { ccx.sess.span_unimpl(cx.sp, "def variant in trans"); } } } fn trans_path(cx: &@block_ctxt, p: &ast::path, id: ast::node_id) -> lval_result { ret trans_var(cx, p.span, id); } fn trans_field(cx: &@block_ctxt, sp: &span, v: ValueRef, t0: &ty::t, field: &ast::ident, id: ast::node_id) -> lval_result { let r = autoderef(cx, v, t0); let t = r.ty; alt ty::struct(bcx_tcx(cx), t) { ty::ty_rec(fields) { let ix: uint = ty::field_idx(bcx_ccx(cx).sess, sp, field, fields); let v = GEP_tup_like(r.bcx, t, r.val, ~[0, ix as int]); ret lval_mem(v.bcx, v.val); } ty::ty_obj(methods) { let ix: uint = ty::method_idx(bcx_ccx(cx).sess, sp, field, methods); let vtbl = r.bcx.build.GEP(r.val, ~[C_int(0), C_int(abi::obj_field_vtbl)]); vtbl = r.bcx.build.Load(vtbl); let vtbl_type = T_ptr(T_array(T_ptr(T_nil()), ix + 1u)); vtbl = cx.build.PointerCast(vtbl, vtbl_type); let v = r.bcx.build.GEP(vtbl, ~[C_int(0), C_int(ix as int)]); let fn_ty: ty::t = ty::method_ty_to_fn_ty(bcx_tcx(cx), methods.(ix)); let tcx = bcx_tcx(cx); let ll_fn_ty = type_of_fn_full(bcx_ccx(cx), sp, ty::ty_fn_proto(tcx, fn_ty), true, ty::ty_fn_args(tcx, fn_ty), ty::ty_fn_ret(tcx, fn_ty), 0u); v = r.bcx.build.PointerCast(v, T_ptr(T_ptr(ll_fn_ty))); let lvo = lval_mem(r.bcx, v); ret {llobj: some[ValueRef](r.val), method_ty: some[ty::t](fn_ty) with lvo}; } _ { bcx_ccx(cx).sess.unimpl("field variant in trans_field"); } } } fn trans_index(cx: &@block_ctxt, sp: &span, base: &@ast::expr, idx: &@ast::expr, id: ast::node_id) -> lval_result { // Is this an interior vector? let base_ty = ty::expr_ty(bcx_tcx(cx), base); let exp = trans_expr(cx, base); let lv = autoderef(exp.bcx, exp.val, base_ty); let base_ty_no_boxes = lv.ty; let is_interior = ty::sequence_is_interior(bcx_tcx(cx), base_ty_no_boxes); let ix = trans_expr(lv.bcx, idx); let v = lv.val; let bcx = ix.bcx; // Cast to an LLVM integer. Rust is less strict than LLVM in this regard. let ix_val; let ix_size = llsize_of_real(bcx_ccx(cx), val_ty(ix.val)); let int_size = llsize_of_real(bcx_ccx(cx), T_int()); if ix_size < int_size { ix_val = bcx.build.ZExt(ix.val, T_int()); } else if (ix_size > int_size) { ix_val = bcx.build.Trunc(ix.val, T_int()); } else { ix_val = ix.val; } let unit_ty = node_id_type(bcx_ccx(cx), id); let unit_sz = size_of(bcx, unit_ty); bcx = unit_sz.bcx; maybe_name_value(bcx_ccx(cx), unit_sz.val, "unit_sz"); let scaled_ix = bcx.build.Mul(ix_val, unit_sz.val); maybe_name_value(bcx_ccx(cx), scaled_ix, "scaled_ix"); let interior_len_and_data; if is_interior { let rslt = ivec::get_len_and_data(bcx, v, unit_ty); interior_len_and_data = some({len: rslt.len, data: rslt.data}); bcx = rslt.bcx; } else { interior_len_and_data = none; } let lim; alt interior_len_and_data { some(lad) { lim = lad.len; } none. { lim = bcx.build.GEP(v, ~[C_int(0), C_int(abi::vec_elt_fill)]); lim = bcx.build.Load(lim); } } let bounds_check = bcx.build.ICmp(lib::llvm::LLVMIntULT, scaled_ix, lim); let fail_cx = new_sub_block_ctxt(bcx, "fail"); let next_cx = new_sub_block_ctxt(bcx, "next"); bcx.build.CondBr(bounds_check, next_cx.llbb, fail_cx.llbb); // fail: bad bounds check. trans_fail(fail_cx, some[span](sp), "bounds check"); let body; alt interior_len_and_data { some(lad) { body = lad.data; } none. { body = next_cx.build.GEP(v, ~[C_int(0), C_int(abi::vec_elt_data), C_int(0)]); } } let elt; if ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty) { body = next_cx.build.PointerCast(body, T_ptr(T_i8())); elt = next_cx.build.GEP(body, ~[scaled_ix]); } else { elt = next_cx.build.GEP(body, ~[ix_val]); // We're crossing a box boundary here, so we may need to pointer cast. let llunitty = type_of(bcx_ccx(next_cx), sp, unit_ty); elt = next_cx.build.PointerCast(elt, T_ptr(llunitty)); } ret lval_mem(next_cx, elt); } // The additional bool returned indicates whether it's mem (that is // represented as an alloca or heap, hence needs a 'load' to be used as an // immediate). fn trans_lval_gen(cx: &@block_ctxt, e: &@ast::expr) -> lval_result { alt e.node { ast::expr_path(p) { ret trans_path(cx, p, e.id); } ast::expr_field(base, ident) { let r = trans_expr(cx, base); let t = ty::expr_ty(bcx_tcx(cx), base); ret trans_field(r.bcx, e.span, r.val, t, ident, e.id); } ast::expr_index(base, idx) { ret trans_index(cx, e.span, base, idx, e.id); } ast::expr_unary(ast::deref., base) { let ccx = bcx_ccx(cx); let sub = trans_expr(cx, base); let t = ty::expr_ty(ccx.tcx, base); let val = alt ty::struct(ccx.tcx, t) { ty::ty_box(_) { sub.bcx.build.InBoundsGEP(sub.val, ~[C_int(0), C_int(abi::box_rc_field_body)]) } ty::ty_uniq(_) { fail "uniq lval translation unimplemented" } ty::ty_res(_, _, _) { sub.bcx.build.InBoundsGEP(sub.val, ~[C_int(0), C_int(1)]) } ty::ty_tag(_, _) { let ety = ty::expr_ty(ccx.tcx, e); let ellty; if ty::type_has_dynamic_size(ccx.tcx, ety) { ellty = T_typaram_ptr(ccx.tn); } else { ellty = T_ptr(type_of(ccx, e.span, ety)); } sub.bcx.build.PointerCast(sub.val, ellty) } ty::ty_ptr(_) { sub.val } }; ret lval_mem(sub.bcx, val); } ast::expr_self_method(ident) { alt { cx.fcx.llself } { some(pair) { let r = pair.v; let t = pair.t; ret trans_field(cx, e.span, r, t, ident, e.id); } _ { // Shouldn't happen. bcx_ccx(cx).sess.bug("trans_lval called on \ expr_self_method in \ a context without llself"); } } } _ { ret {res: trans_expr(cx, e), is_mem: false, generic: none, llobj: none, method_ty: none}; } } } fn trans_lval(cx: &@block_ctxt, e: &@ast::expr) -> lval_result { let lv = trans_lval_gen(cx, e); alt lv.generic { some(gi) { let t = ty::expr_ty(bcx_tcx(cx), e); let n_args = std::ivec::len(ty::ty_fn_args(bcx_tcx(cx), t)); let args = std::ivec::init_elt(none[@ast::expr], n_args); let bound = trans_bind_1(lv.res.bcx, e, lv, args, e.id); ret lval_val(bound.bcx, bound.val); } none. { ret lv; } } } fn int_cast(bcx: &@block_ctxt, lldsttype: TypeRef, llsrctype: TypeRef, llsrc: ValueRef, signed: bool) -> ValueRef { let srcsz = llvm::LLVMGetIntTypeWidth(llsrctype); let dstsz = llvm::LLVMGetIntTypeWidth(lldsttype); ret if dstsz == srcsz { bcx.build.BitCast(llsrc, lldsttype) } else if (srcsz > dstsz) { bcx.build.TruncOrBitCast(llsrc, lldsttype) } else if (signed) { bcx.build.SExtOrBitCast(llsrc, lldsttype) } else { bcx.build.ZExtOrBitCast(llsrc, lldsttype) }; } fn float_cast(bcx: &@block_ctxt, lldsttype: TypeRef, llsrctype: TypeRef, llsrc: ValueRef) -> ValueRef { let srcsz = lib::llvm::float_width(llsrctype); let dstsz = lib::llvm::float_width(lldsttype); ret if dstsz > srcsz { bcx.build.FPExt(llsrc, lldsttype) } else if (srcsz > dstsz) { bcx.build.FPTrunc(llsrc, lldsttype) } else { llsrc }; } fn trans_cast(cx: &@block_ctxt, e: &@ast::expr, id: ast::node_id) -> result { let ccx = bcx_ccx(cx); let e_res = trans_expr(cx, e); let ll_t_in = val_ty(e_res.val); let t_in = ty::expr_ty(ccx.tcx, e); let t_out = node_id_type(ccx, id); let ll_t_out = type_of(ccx, e.span, t_out); tag kind { native_; integral; float; other; } fn t_kind(tcx: &ty::ctxt, t: ty::t) -> kind { ret if ty::type_is_fp(tcx, t) { float } else if (ty::type_is_native(tcx, t)) { native_ } else if (ty::type_is_integral(tcx, t)) { integral } else { other }; } let k_in = t_kind(ccx.tcx, t_in); let k_out = t_kind(ccx.tcx, t_out); let s_in = k_in == integral && ty::type_is_signed(ccx.tcx, t_in); let newval = alt {in: k_in, out: k_out} { {in: integral., out: integral.} { int_cast(e_res.bcx, ll_t_out, ll_t_in, e_res.val, s_in) } {in: float., out: float.} { float_cast(e_res.bcx, ll_t_out, ll_t_in, e_res.val) } {in: integral., out: float.} { if s_in { e_res.bcx.build.SIToFP(e_res.val, ll_t_out) } else { e_res.bcx.build.UIToFP(e_res.val, ll_t_out) } } {in: float., out: integral.} { if ty::type_is_signed(ccx.tcx, t_out) { e_res.bcx.build.FPToSI(e_res.val, ll_t_out) } else { e_res.bcx.build.FPToUI(e_res.val, ll_t_out) } } {in: integral., out: native_.} { e_res.bcx.build.IntToPtr(e_res.val, ll_t_out) } {in: native_., out: integral.} { e_res.bcx.build.PtrToInt(e_res.val, ll_t_out) } {in: native_., out: native_.} { e_res.bcx.build.PointerCast(e_res.val, ll_t_out) } _ { ccx.sess.bug("Translating unsupported cast.") } }; ret rslt(e_res.bcx, newval); } fn trans_bind_thunk(cx: &@local_ctxt, sp: &span, incoming_fty: &ty::t, outgoing_fty: &ty::t, args: &[option::t[@ast::expr]], env_ty: &ty::t, bound_tys: &[ty::t], ty_param_count: uint) -> {val: ValueRef, ty: TypeRef} { // Here we're not necessarily constructing a thunk in the sense of // "function with no arguments". The result of compiling 'bind f(foo, // bar, baz)' would be a thunk that, when called, applies f to those // arguments and returns the result. But we're stretching the meaning of // the word "thunk" here to also mean the result of compiling, say, 'bind // f(foo, _, baz)', or any other bind expression that binds f and leaves // some (or all) of the arguments unbound. // Here, 'incoming_fty' is the type of the entire bind expression, while // 'outgoing_fty' is the type of the function that is having some of its // arguments bound. If f is a function that takes three arguments of type // int and returns int, and we're translating, say, 'bind f(3, _, 5)', // then outgoing_fty is the type of f, which is (int, int, int) -> int, // and incoming_fty is the type of 'bind f(3, _, 5)', which is int -> int. // Once translated, the entire bind expression will be the call f(foo, // bar, baz) wrapped in a (so-called) thunk that takes 'bar' as its // argument and that has bindings of 'foo' to 3 and 'baz' to 5 and a // pointer to 'f' all saved in its environment. So, our job is to // construct and return that thunk. // Give the thunk a name, type, and value. let s: str = mangle_internal_name_by_path_and_seq(cx.ccx, cx.path, "thunk"); let llthunk_ty: TypeRef = get_pair_fn_ty(type_of(cx.ccx, sp, incoming_fty)); let llthunk: ValueRef = decl_internal_fastcall_fn(cx.ccx.llmod, s, llthunk_ty); // Create a new function context and block context for the thunk, and hold // onto a pointer to the first block in the function for later use. let fcx = new_fn_ctxt(cx, sp, llthunk); let bcx = new_top_block_ctxt(fcx); let lltop = bcx.llbb; // Since we might need to construct derived tydescs that depend on // our bound tydescs, we need to load tydescs out of the environment // before derived tydescs are constructed. To do this, we load them // in the copy_args block. let copy_args_bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs); // The 'llenv' that will arrive in the thunk we're creating is an // environment that will contain the values of its arguments and a pointer // to the original function. So, let's create one of those: // The llenv pointer needs to be the correct size. That size is // 'closure_ty', which was determined by trans_bind. let closure_ty = ty::mk_imm_box(cx.ccx.tcx, env_ty); let llclosure_ptr_ty = type_of(cx.ccx, sp, closure_ty); let llclosure = copy_args_bcx.build.PointerCast(fcx.llenv, llclosure_ptr_ty); // "target", in this context, means the function that's having some of its // arguments bound and that will be called inside the thunk we're // creating. (In our running example, target is the function f.) Pick // out the pointer to the target function from the environment. The // target function lives in the first binding spot. let lltarget = GEP_tup_like(bcx, closure_ty, llclosure, ~[0, abi::box_rc_field_body, abi::closure_elt_bindings, 0]); bcx = lltarget.bcx; // And then, pick out the target function's own environment. That's what // we'll use as the environment the thunk gets. let lltargetclosure = bcx.build.GEP(lltarget.val, ~[C_int(0), C_int(abi::fn_field_box)]); lltargetclosure = bcx.build.Load(lltargetclosure); // Get f's return type, which will also be the return type of the entire // bind expression. let outgoing_ret_ty = ty::ty_fn_ret(cx.ccx.tcx, outgoing_fty); // Get the types of the arguments to f. let outgoing_args = ty::ty_fn_args(cx.ccx.tcx, outgoing_fty); // The 'llretptr' that will arrive in the thunk we're creating also needs // to be the correct type. Cast it to f's return type, if necessary. let llretptr = fcx.llretptr; if ty::type_contains_params(cx.ccx.tcx, outgoing_ret_ty) { let llretty = type_of_inner(cx.ccx, sp, outgoing_ret_ty); llretptr = bcx.build.PointerCast(llretptr, T_ptr(llretty)); } // Set up the three implicit arguments to the thunk. let llargs: [ValueRef] = ~[llretptr, fcx.lltaskptr, lltargetclosure]; // Copy in the type parameters. let i: uint = 0u; while i < ty_param_count { let lltyparam_ptr = GEP_tup_like(copy_args_bcx, closure_ty, llclosure, ~[0, abi::box_rc_field_body, abi::closure_elt_ty_params, i as int]); copy_args_bcx = lltyparam_ptr.bcx; let td = copy_args_bcx.build.Load(lltyparam_ptr.val); llargs += ~[td]; fcx.lltydescs += ~[td]; i += 1u; } let a: uint = 3u; // retptr, task ptr, env come first let b: int = 1; let outgoing_arg_index: uint = 0u; let llout_arg_tys: [TypeRef] = type_of_explicit_args(cx.ccx, sp, outgoing_args); for arg: option::t[@ast::expr] in args { let out_arg = outgoing_args.(outgoing_arg_index); let llout_arg_ty = llout_arg_tys.(outgoing_arg_index); let is_val = out_arg.mode == ty::mo_val; alt arg { // Arg provided at binding time; thunk copies it from // closure. some(e) { let e_ty = ty::expr_ty(cx.ccx.tcx, e); let bound_arg = GEP_tup_like(bcx, closure_ty, llclosure, ~[0, abi::box_rc_field_body, abi::closure_elt_bindings, b]); bcx = bound_arg.bcx; let val = bound_arg.val; // If the type is parameterized, then we need to cast the // type we actually have to the parameterized out type. if ty::type_contains_params(cx.ccx.tcx, out_arg.ty) { let ty = if is_val { T_ptr(llout_arg_ty) } else { llout_arg_ty }; val = bcx.build.PointerCast(val, ty); } if is_val { if type_is_immediate(cx.ccx, e_ty) { val = bcx.build.Load(val); bcx = copy_ty(bcx, val, e_ty).bcx; } else { bcx = copy_ty(bcx, val, e_ty).bcx; val = bcx.build.Load(val); } } llargs += ~[val]; b += 1; } // Arg will be provided when the thunk is invoked. none. { let arg: ValueRef = llvm::LLVMGetParam(llthunk, a); if ty::type_contains_params(cx.ccx.tcx, out_arg.ty) { // If the argument was passed by value and isn't a // pointer type, we need to spill it to an alloca in // order to do a pointer cast. Argh. if is_val && !ty::type_is_boxed(cx.ccx.tcx, out_arg.ty) { let argp = do_spill(bcx, arg); argp = bcx.build.PointerCast(argp, T_ptr(llout_arg_ty)); arg = bcx.build.Load(argp); } else { arg = bcx.build.PointerCast(arg, llout_arg_ty); } } llargs += ~[arg]; a += 1u; } } outgoing_arg_index += 1u; } let lltargetfn = bcx.build.GEP(lltarget.val, ~[C_int(0), C_int(abi::fn_field_code)]); // Cast the outgoing function to the appropriate type. // This is necessary because the type of the function that we have // in the closure does not know how many type descriptors the function // needs to take. let lltargetty = type_of_fn_from_ty(bcx_ccx(bcx), sp, outgoing_fty, ty_param_count); lltargetfn = bcx.build.PointerCast(lltargetfn, T_ptr(T_ptr(lltargetty))); lltargetfn = bcx.build.Load(lltargetfn); llvm::LLVMSetTailCall(bcx.build.FastCall(lltargetfn, llargs), 1); bcx.build.RetVoid(); finish_fn(fcx, lltop); ret {val: llthunk, ty: llthunk_ty}; } fn trans_bind(cx: &@block_ctxt, f: &@ast::expr, args: &[option::t[@ast::expr]], id: ast::node_id) -> result { let f_res = trans_lval_gen(cx, f); ret trans_bind_1(cx, f, f_res, args, id); } fn trans_bind_1(cx: &@block_ctxt, f: &@ast::expr, f_res: &lval_result, args: &[option::t[@ast::expr]], id: ast::node_id) -> result { let bound: [@ast::expr] = ~[]; for argopt: option::t[@ast::expr] in args { alt argopt { none. { } some(e) { bound += ~[e]; } } } // Figure out which tydescs we need to pass, if any. let outgoing_fty: ty::t = ty::expr_ty(bcx_tcx(cx), f); let outgoing_fty_real; // the type with typarams still in it let lltydescs: [ValueRef]; alt f_res.generic { none. { outgoing_fty_real = outgoing_fty; lltydescs = ~[]; } some(ginfo) { lazily_emit_all_generic_info_tydesc_glues(cx, ginfo); outgoing_fty_real = ginfo.item_type; lltydescs = ginfo.tydescs; } } let ty_param_count = std::ivec::len(lltydescs); if std::ivec::len(bound) == 0u && ty_param_count == 0u { // Trivial 'binding': just return the static pair-ptr. ret f_res.res; } let bcx = f_res.res.bcx; // Cast the function we are binding to be the type that the closure // will expect it to have. The type the closure knows about has the // type parameters substituted with the real types. let llclosurety = T_ptr(type_of(bcx_ccx(cx), cx.sp, outgoing_fty)); let src_loc = bcx.build.PointerCast(f_res.res.val, llclosurety); let bound_f = {res: {bcx: bcx, val: src_loc} with f_res}; // Arrange for the bound function to live in the first binding spot. let bound_tys: [ty::t] = ~[outgoing_fty]; let bound_vals: [lval_result] = ~[bound_f]; // Translate the bound expressions. for e: @ast::expr in bound { let lv = trans_lval(bcx, e); bcx = lv.res.bcx; bound_vals += ~[lv]; bound_tys += ~[ty::expr_ty(bcx_tcx(cx), e)]; } // Actually construct the closure let closure = build_environment(bcx, lltydescs, bound_tys, bound_vals, true); bcx = closure.bcx; // Make thunk // The type of the entire bind expression. let pair_ty = node_id_type(bcx_ccx(cx), id); let llthunk = trans_bind_thunk(cx.fcx.lcx, cx.sp, pair_ty, outgoing_fty_real, args, closure.ptrty, bound_tys, ty_param_count); // Construct the function pair let pair_v = create_real_fn_pair(bcx, llthunk.ty, llthunk.val, closure.ptr); add_clean_temp(cx, pair_v, pair_ty); ret rslt(bcx, pair_v); } fn trans_arg_expr(cx: &@block_ctxt, arg: &ty::arg, lldestty0: TypeRef, to_zero: &mutable[{v:ValueRef, t: ty::t}], to_revoke: &mutable[ValueRef], e: &@ast::expr) -> result { let ccx = bcx_ccx(cx); let e_ty = ty::expr_ty(ccx.tcx, e); let is_bot = ty::type_is_bot(ccx.tcx, e_ty); let lv = trans_lval(cx, e); let bcx = lv.res.bcx; let val = lv.res.val; if is_bot { // For values of type _|_, we generate an // "undef" value, as such a value should never // be inspected. It's important for the value // to have type lldestty0 (the callee's expected type). val = llvm::LLVMGetUndef(lldestty0); } else if (arg.mode == ty::mo_val) { if ty::type_owns_heap_mem(ccx.tcx, e_ty) { let dst = alloc_ty(bcx, e_ty); val = dst.val; bcx = move_val_if_temp(dst.bcx, INIT, val, lv, e_ty).bcx; } else if (lv.is_mem) { val = load_if_immediate(bcx, val, e_ty); bcx = copy_ty(bcx, val, e_ty).bcx; } else { // Eliding take/drop for appending of external vectors currently // corrupts memory. I can't figure out why, and external vectors // are on the way out anyway, so this simply turns off the // optimization for that case. let is_ext_vec_plus = alt e.node { ast::expr_binary(_, _, _) { ty::type_is_sequence(ccx.tcx, e_ty) && !ty::sequence_is_interior(ccx.tcx, e_ty) } _ { false } }; if is_ext_vec_plus { bcx = copy_ty(bcx, val, e_ty).bcx; } else { revoke_clean(bcx, val); } } } else if (type_is_immediate(ccx, e_ty) && !lv.is_mem) { val = do_spill(bcx, val); } if !is_bot && ty::type_contains_params(ccx.tcx, arg.ty) { let lldestty = lldestty0; if arg.mode == ty::mo_val && ty::type_is_structural(ccx.tcx, e_ty) { lldestty = T_ptr(lldestty); } val = bcx.build.PointerCast(val, lldestty); } if arg.mode == ty::mo_val && ty::type_is_structural(ccx.tcx, e_ty) { // Until here we've been treating structures by pointer; // we are now passing it as an arg, so need to load it. val = bcx.build.Load(val); } // Collect arg for later if it happens to be one we've moving out. if arg.mode == ty::mo_move { if lv.is_mem { // Use actual ty, not declared ty -- anything else doesn't make sense // if declared ty is a ty param to_zero += ~[{v: lv.res.val, t: e_ty}]; } else { to_revoke += ~[lv.res.val]; } } ret rslt(bcx, val); } // NB: must keep 4 fns in sync: // // - type_of_fn_full // - create_llargs_for_fn_args. // - new_fn_ctxt // - trans_args fn trans_args(cx: &@block_ctxt, llenv: ValueRef, gen: &option::t[generic_info], lliterbody: &option::t[ValueRef], es: &[@ast::expr], fn_ty: &ty::t) -> {bcx: @block_ctxt, args: [ValueRef], retslot: ValueRef, to_zero: [{v:ValueRef, t: ty::t}], to_revoke: [ValueRef] } { let args: [ty::arg] = ty::ty_fn_args(bcx_tcx(cx), fn_ty); let llargs: [ValueRef] = ~[]; let lltydescs: [ValueRef] = ~[]; let to_zero = ~[]; let to_revoke = ~[]; let bcx: @block_ctxt = cx; // Arg 0: Output pointer. // FIXME: test case looks like // f(1, fail, @42); if bcx.build.is_terminated() { // This means an earlier arg was divergent. // So this arg can't be evaluated. ret {bcx: bcx, args: ~[], retslot: C_nil(), to_zero: to_zero, to_revoke: to_revoke}; } let retty = ty::ty_fn_ret(bcx_tcx(cx), fn_ty); let llretslot_res = alloc_ty(bcx, retty); bcx = llretslot_res.bcx; let llretslot = llretslot_res.val; alt gen { some(g) { lazily_emit_all_generic_info_tydesc_glues(cx, g); lltydescs = g.tydescs; args = ty::ty_fn_args(bcx_tcx(cx), g.item_type); retty = ty::ty_fn_ret(bcx_tcx(cx), g.item_type); } _ { } } if (ty::type_contains_params(bcx_tcx(cx), retty)) { // It's possible that the callee has some generic-ness somewhere in // its return value -- say a method signature within an obj or a fn // type deep in a structure -- which the caller has a concrete view // of. If so, cast the caller's view of the restlot to the callee's // view, for the sake of making a type-compatible call. let llretty = T_ptr(type_of_inner(bcx_ccx(bcx), bcx.sp, retty)); llargs += ~[cx.build.PointerCast(llretslot, llretty)]; } else { llargs += ~[llretslot]; } // Arg 1: task pointer. llargs += ~[bcx.fcx.lltaskptr]; // Arg 2: Env (closure-bindings / self-obj) llargs += ~[llenv]; // Args >3: ty_params ... llargs += lltydescs; // ... then possibly an lliterbody argument. alt lliterbody { none. { } some(lli) { llargs += ~[lli]; } } // ... then explicit args. // First we figure out the caller's view of the types of the arguments. // This will be needed if this is a generic call, because the callee has // to cast her view of the arguments to the caller's view. let arg_tys = type_of_explicit_args(bcx_ccx(cx), cx.sp, args); let i = 0u; for e: @ast::expr in es { if bcx.build.is_terminated() { // This means an earlier arg was divergent. // So this arg can't be evaluated. break; } let r = trans_arg_expr(bcx, args.(i), arg_tys.(i), to_zero, to_revoke, e); bcx = r.bcx; llargs += ~[r.val]; i += 1u; } ret {bcx: bcx, args: llargs, retslot: llretslot, to_zero: to_zero, to_revoke: to_revoke}; } fn trans_call(cx: &@block_ctxt, f: &@ast::expr, lliterbody: &option::t[ValueRef], args: &[@ast::expr], id: ast::node_id) -> result { // NB: 'f' isn't necessarily a function; it might be an entire self-call // expression because of the hack that allows us to process self-calls // with trans_call. let f_res = trans_lval_gen(cx, f); let fn_ty: ty::t; alt f_res.method_ty { some(meth) { // self-call fn_ty = meth; } _ { fn_ty = ty::expr_ty(bcx_tcx(cx), f); } } let bcx = f_res.res.bcx; let faddr = f_res.res.val; let llenv = C_null(T_opaque_closure_ptr(*bcx_ccx(cx))); alt f_res.llobj { some(ob) { // It's a vtbl entry. faddr = bcx.build.Load(faddr); llenv = ob; } none. { // It's a closure. We have to autoderef. if f_res.is_mem { faddr = load_if_immediate(bcx, faddr, fn_ty); } let res = autoderef(bcx, faddr, fn_ty); bcx = res.bcx; fn_ty = res.ty; let pair = res.val; faddr = bcx.build.GEP(pair, ~[C_int(0), C_int(abi::fn_field_code)]); faddr = bcx.build.Load(faddr); let llclosure = bcx.build.GEP(pair, ~[C_int(0), C_int(abi::fn_field_box)]); llenv = bcx.build.Load(llclosure); } } let ret_ty = ty::node_id_to_type(bcx_tcx(cx), id); let args_res = trans_args(bcx, llenv, f_res.generic, lliterbody, args, fn_ty); bcx = args_res.bcx; let llargs = args_res.args; let llretslot = args_res.retslot; /* log "calling: " + val_str(bcx_ccx(cx).tn, faddr); for arg: ValueRef in llargs { log "arg: " + val_str(bcx_ccx(cx).tn, arg); } */ /* If the block is terminated, then one or more of the args has type _|_. Since that means it diverges, the code for the call itself is unreachable. */ let retval = C_nil(); if !bcx.build.is_terminated() { bcx.build.FastCall(faddr, llargs); alt lliterbody { none. { if !ty::type_is_nil(bcx_tcx(cx), ret_ty) { retval = load_if_immediate(bcx, llretslot, ret_ty); // Retval doesn't correspond to anything really tangible // in the frame, but it's a ref all the same, so we put a // note here to drop it when we're done in this scope. add_clean_temp(cx, retval, ret_ty); } } some(_) { // If there was an lliterbody, it means we were calling an // iter, and we are *not* the party using its 'output' value, // we should ignore llretslot. } } // Forget about anything we moved out. for {v,t}: {v: ValueRef, t: ty::t} in args_res.to_zero { zero_alloca(bcx, v, t) } for v: ValueRef in args_res.to_revoke { revoke_clean(bcx, v) } } ret rslt(bcx, retval); } fn trans_tup(cx: &@block_ctxt, elts: &[@ast::expr], id: ast::node_id) -> result { let bcx = cx; let t = node_id_type(bcx.fcx.lcx.ccx, id); let tup_res = alloc_ty(bcx, t); let tup_val = tup_res.val; bcx = tup_res.bcx; add_clean_temp(cx, tup_val, t); let i: int = 0; for e in elts { let e_ty = ty::expr_ty(cx.fcx.lcx.ccx.tcx, e); let src = trans_lval(bcx, e); bcx = src.res.bcx; let dst_res = GEP_tup_like(bcx, t, tup_val, ~[0, i]); bcx = move_val_if_temp(dst_res.bcx, INIT, dst_res.val, src, e_ty).bcx; i += 1; } ret rslt(bcx, tup_val); } fn trans_vec(cx: &@block_ctxt, args: &[@ast::expr], id: ast::node_id) -> result { let t = node_id_type(bcx_ccx(cx), id); let unit_ty = t; alt ty::struct(bcx_tcx(cx), t) { ty::ty_vec(mt) { unit_ty = mt.ty; } _ { bcx_ccx(cx).sess.bug("non-vec type in trans_vec"); } } let bcx = cx; let unit_sz = size_of(bcx, unit_ty); bcx = unit_sz.bcx; let data_sz = bcx.build.Mul(C_uint(std::ivec::len[@ast::expr](args)), unit_sz.val); // FIXME: pass tydesc properly. let vec_val = bcx.build.Call(bcx_ccx(bcx).upcalls.new_vec, ~[bcx.fcx.lltaskptr, data_sz, C_null(T_ptr(bcx_ccx(bcx).tydesc_type))]); let llty = type_of(bcx_ccx(bcx), bcx.sp, t); vec_val = bcx.build.PointerCast(vec_val, llty); add_clean_temp(bcx, vec_val, t); let body = bcx.build.GEP(vec_val, ~[C_int(0), C_int(abi::vec_elt_data)]); let pseudo_tup_ty = ty::mk_tup(bcx_tcx(cx), std::ivec::init_elt[ty::t](unit_ty, std::ivec::len(args))); let i: int = 0; for e: @ast::expr in args { let src = trans_lval(bcx, e); bcx = src.res.bcx; let dst_res = GEP_tup_like(bcx, pseudo_tup_ty, body, ~[0, i]); bcx = dst_res.bcx; // Cast the destination type to the source type. This is needed to // make tags work, for a subtle combination of reasons: // // (1) "dst_res" above is derived from "body", which is in turn // derived from "vec_val". // (2) "vec_val" has the LLVM type "llty". // (3) "llty" is the result of calling type_of() on a vector type. // (4) For tags, type_of() returns a different type depending on // on whether the tag is behind a box or not. Vector types are // considered boxes. // (5) "src_res" is derived from "unit_ty", which is not behind a box. let dst_val; if !ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty) { let llunit_ty = type_of(bcx_ccx(cx), bcx.sp, unit_ty); dst_val = bcx.build.PointerCast(dst_res.val, T_ptr(llunit_ty)); } else { dst_val = dst_res.val; } bcx = move_val_if_temp(bcx, INIT, dst_val, src, unit_ty).bcx; i += 1; } let fill = bcx.build.GEP(vec_val, ~[C_int(0), C_int(abi::vec_elt_fill)]); bcx.build.Store(data_sz, fill); ret rslt(bcx, vec_val); } // TODO: Move me to ivec:: fn trans_ivec(bcx: @block_ctxt, args: &[@ast::expr], id: ast::node_id) -> result { let typ = node_id_type(bcx_ccx(bcx), id); let unit_ty; alt ty::struct(bcx_tcx(bcx), typ) { ty::ty_ivec(mt) { unit_ty = mt.ty; } _ { bcx_ccx(bcx).sess.bug("non-ivec type in trans_ivec"); } } let llunitty = type_of_or_i8(bcx, unit_ty); let ares = ivec::alloc(bcx, unit_ty); bcx = ares.bcx; let llvecptr = ares.llptr; let unit_sz = ares.llunitsz; let llalen = ares.llalen; add_clean_temp(bcx, llvecptr, typ); let lllen = bcx.build.Mul(C_uint(std::ivec::len(args)), unit_sz); // Allocate the vector pieces and store length and allocated length. let llfirsteltptr; if std::ivec::len(args) > 0u && std::ivec::len(args) <= abi::ivec_default_length { // Interior case. bcx.build.Store(lllen, bcx.build.InBoundsGEP(llvecptr, ~[C_int(0), C_uint(abi::ivec_elt_len)])); bcx.build.Store(llalen, bcx.build.InBoundsGEP(llvecptr, ~[C_int(0), C_uint(abi::ivec_elt_alen)])); llfirsteltptr = bcx.build.InBoundsGEP(llvecptr, ~[C_int(0), C_uint(abi::ivec_elt_elems), C_int(0)]); } else { // Heap case. let stub_z = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_zero)]; let stub_a = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_alen)]; let stub_p = ~[C_int(0), C_uint(abi::ivec_heap_stub_elt_ptr)]; let llstubty = T_ivec_heap(llunitty); let llstubptr = bcx.build.PointerCast(llvecptr, T_ptr(llstubty)); bcx.build.Store(C_int(0), bcx.build.InBoundsGEP(llstubptr, stub_z)); let llheapty = T_ivec_heap_part(llunitty); if std::ivec::len(args) == 0u { // Null heap pointer indicates a zero-length vector. bcx.build.Store(llalen, bcx.build.InBoundsGEP(llstubptr, stub_a)); bcx.build.Store(C_null(T_ptr(llheapty)), bcx.build.InBoundsGEP(llstubptr, stub_p)); llfirsteltptr = C_null(T_ptr(llunitty)); } else { bcx.build.Store(lllen, bcx.build.InBoundsGEP(llstubptr, stub_a)); let llheapsz = bcx.build.Add(llsize_of(llheapty), lllen); let rslt = trans_shared_malloc(bcx, T_ptr(llheapty), llheapsz); bcx = rslt.bcx; let llheapptr = rslt.val; bcx.build.Store(llheapptr, bcx.build.InBoundsGEP(llstubptr, stub_p)); let heap_l = ~[C_int(0), C_uint(abi::ivec_heap_elt_len)]; bcx.build.Store(lllen, bcx.build.InBoundsGEP(llheapptr, heap_l)); llfirsteltptr = bcx.build.InBoundsGEP(llheapptr, ~[C_int(0), C_uint(abi::ivec_heap_elt_elems), C_int(0)]); } } // Store the individual elements. let i = 0u; for e: @ast::expr in args { let lv = trans_lval(bcx, e); bcx = lv.res.bcx; let lleltptr; if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) { lleltptr = bcx.build.InBoundsGEP(llfirsteltptr, ~[bcx.build.Mul(C_uint(i), unit_sz)]); } else { lleltptr = bcx.build.InBoundsGEP(llfirsteltptr, ~[C_uint(i)]); } bcx = move_val_if_temp(bcx, INIT, lleltptr, lv, unit_ty).bcx; i += 1u; } ret rslt(bcx, llvecptr); } fn trans_rec(cx: &@block_ctxt, fields: &[ast::field], base: &option::t[@ast::expr], id: ast::node_id) -> result { let bcx = cx; let t = node_id_type(bcx_ccx(bcx), id); let rec_res = alloc_ty(bcx, t); let rec_val = rec_res.val; bcx = rec_res.bcx; add_clean_temp(cx, rec_val, t); let i: int = 0; let base_val = C_nil(); alt base { none. { } some(bexp) { let base_res = trans_expr(bcx, bexp); bcx = base_res.bcx; base_val = base_res.val; } } let ty_fields: [ty::field] = ~[]; alt ty::struct(bcx_tcx(cx), t) { ty::ty_rec(flds) { ty_fields = flds; } } for tf: ty::field in ty_fields { let e_ty = tf.mt.ty; let dst_res = GEP_tup_like(bcx, t, rec_val, ~[0, i]); bcx = dst_res.bcx; let expr_provided = false; for f: ast::field in fields { if str::eq(f.node.ident, tf.ident) { expr_provided = true; let lv = trans_lval(bcx, f.node.expr); bcx = move_val_if_temp(lv.res.bcx, INIT, dst_res.val, lv, e_ty).bcx; break; } } if !expr_provided { let src_res = GEP_tup_like(bcx, t, base_val, ~[0, i]); src_res = rslt(src_res.bcx, load_if_immediate(bcx, src_res.val, e_ty)); bcx = copy_val(src_res.bcx, INIT, dst_res.val, src_res.val, e_ty).bcx; } i += 1; } ret rslt(bcx, rec_val); } fn trans_expr(cx: &@block_ctxt, e: &@ast::expr) -> result { ret trans_expr_out(cx, e, return); } fn trans_expr_out(cx: &@block_ctxt, e: &@ast::expr, output: out_method) -> result { // FIXME Fill in cx.sp alt e.node { ast::expr_lit(lit) { ret trans_lit(cx, *lit); } ast::expr_unary(op, x) { if op != ast::deref { ret trans_unary(cx, op, x, e.id); } } ast::expr_binary(op, x, y) { ret trans_binary(cx, op, x, y); } ast::expr_if(cond, thn, els) { ret with_out_method(bind trans_if(cx, cond, thn, els, e.id, _), cx, e.id, output); } ast::expr_if_check(cond, thn, els) { ret with_out_method(bind trans_if(cx, cond, thn, els, e.id, _), cx, e.id, output); } ast::expr_ternary(_, _, _) { ret trans_expr_out(cx, ast::ternary_to_if(e), output); } ast::expr_for(decl, seq, body) { ret trans_for(cx, decl, seq, body); } ast::expr_for_each(decl, seq, body) { ret trans_for_each(cx, decl, seq, body); } ast::expr_while(cond, body) { ret trans_while(cx, cond, body); } ast::expr_do_while(body, cond) { ret trans_do_while(cx, body, cond); } ast::expr_alt(expr, arms) { ret with_out_method(bind trans_alt::trans_alt(cx, expr, arms, e.id, _), cx, e.id, output); } ast::expr_fn(f) { let ccx = bcx_ccx(cx); let llfnty: TypeRef = type_of_fn_from_ty(ccx, e.span, node_id_type(ccx, e.id), 0u); let sub_cx = extend_path(cx.fcx.lcx, ccx.names.next("anon")); let s = mangle_internal_name_by_path(ccx, sub_cx.path); let llfn = decl_internal_fastcall_fn(ccx.llmod, s, llfnty); let fn_res = trans_closure(some(cx), some(llfnty), sub_cx, e.span, f, llfn, none, ~[], e.id); let fn_pair = alt fn_res { some(fn_pair) { fn_pair } none. { {fn_pair: create_fn_pair(ccx, s, llfnty, llfn, false), bcx: cx} } }; ret rslt(fn_pair.bcx, fn_pair.fn_pair); } ast::expr_block(blk) { let sub_cx = new_scope_block_ctxt(cx, "block-expr body"); let next_cx = new_sub_block_ctxt(cx, "next"); let sub = with_out_method(bind trans_block(sub_cx, blk, _), cx, e.id, output); cx.build.Br(sub_cx.llbb); sub.bcx.build.Br(next_cx.llbb); ret rslt(next_cx, sub.val); } ast::expr_copy(a) { // FIXME: this has more-subtle semantics than just "fall through". ret trans_expr_out(cx, a, output); } ast::expr_move(dst, src) { let lhs_res = trans_lval(cx, dst); assert (lhs_res.is_mem); // FIXME Fill in lhs_res.res.bcx.sp let rhs_res = trans_lval(lhs_res.res.bcx, src); let t = ty::expr_ty(bcx_tcx(cx), src); // FIXME: calculate copy init-ness in typestate. let move_res = move_val(rhs_res.res.bcx, DROP_EXISTING, lhs_res.res.val, rhs_res, t); ret rslt(move_res.bcx, C_nil()); } ast::expr_assign(dst, src) { let lhs_res = trans_lval(cx, dst); assert (lhs_res.is_mem); // FIXME Fill in lhs_res.res.bcx.sp let rhs = trans_lval(lhs_res.res.bcx, src); let t = ty::expr_ty(bcx_tcx(cx), src); // FIXME: calculate copy init-ness in typestate. let copy_res = move_val_if_temp(rhs.res.bcx, DROP_EXISTING, lhs_res.res.val, rhs, t); ret rslt(copy_res.bcx, C_nil()); } ast::expr_swap(dst, src) { let lhs_res = trans_lval(cx, dst); assert (lhs_res.is_mem); // FIXME Fill in lhs_res.res.bcx.sp let rhs_res = trans_lval(lhs_res.res.bcx, src); let t = ty::expr_ty(bcx_tcx(cx), src); let tmp_res = alloc_ty(rhs_res.res.bcx, t); // Swap through a temporary. let move1_res = memmove_ty(tmp_res.bcx, tmp_res.val, lhs_res.res.val, t); let move2_res = memmove_ty(move1_res.bcx, lhs_res.res.val, rhs_res.res.val, t); let move3_res = memmove_ty(move2_res.bcx, rhs_res.res.val, tmp_res.val, t); ret rslt(move3_res.bcx, C_nil()); } ast::expr_assign_op(op, dst, src) { let t = ty::expr_ty(bcx_tcx(cx), src); let lhs_res = trans_lval(cx, dst); assert (lhs_res.is_mem); // FIXME Fill in lhs_res.res.bcx.sp let rhs_res = trans_expr(lhs_res.res.bcx, src); if ty::type_is_sequence(bcx_tcx(cx), t) { alt op { ast::add. { if ty::sequence_is_interior(bcx_tcx(cx), t) { ret ivec::trans_append(rhs_res.bcx, t, lhs_res.res.val, rhs_res.val); } ret trans_vec_append(rhs_res.bcx, t, lhs_res.res.val, rhs_res.val); } _ { } } } let lhs_val = load_if_immediate(rhs_res.bcx, lhs_res.res.val, t); let v = trans_eager_binop(rhs_res.bcx, op, lhs_val, t, rhs_res.val, t); // FIXME: calculate copy init-ness in typestate. // This is always a temporary, so can always be safely moved let move_res = move_val(v.bcx, DROP_EXISTING, lhs_res.res.val, lval_val(v.bcx, v.val), t); ret rslt(move_res.bcx, C_nil()); } ast::expr_bind(f, args) { ret trans_bind(cx, f, args, e.id); } ast::expr_call(f, args) { ret trans_call(cx, f, none[ValueRef], args, e.id); } ast::expr_cast(val, _) { ret trans_cast(cx, val, e.id); } ast::expr_vec(args, _, ast::sk_rc.) { ret trans_vec(cx, args, e.id); } ast::expr_vec(args, _, ast::sk_unique.) { ret trans_ivec(cx, args, e.id); } ast::expr_rec(args, base) { ret trans_rec(cx, args, base, e.id); } ast::expr_tup(args) { ret trans_tup(cx, args, e.id); } ast::expr_mac(_) { ret bcx_ccx(cx).sess.bug("unexpanded macro"); } ast::expr_fail(expr) { ret trans_fail_expr(cx, some(e.span), expr); } ast::expr_log(lvl, a) { ret trans_log(lvl, cx, a); } ast::expr_assert(a) { ret trans_check_expr(cx, a, "Assertion"); } ast::expr_check(ast::checked., a) { ret trans_check_expr(cx, a, "Predicate"); } ast::expr_check(ast::unchecked., a) { /* Claims are turned on and off by a global variable that the RTS sets. This case generates code to check the value of that variable, doing nothing if it's set to false and acting like a check otherwise. */ let c = get_extern_const(bcx_ccx(cx).externs, bcx_ccx(cx).llmod, "check_claims", T_bool()); let cond = cx.build.Load(c); let then_cx = new_scope_block_ctxt(cx, "claim_then"); let check_res = trans_check_expr(then_cx, a, "Claim"); let else_cx = new_scope_block_ctxt(cx, "else"); let els = rslt(else_cx, C_nil()); cx.build.CondBr(cond, then_cx.llbb, else_cx.llbb); ret rslt(join_branches(cx, ~[check_res, els]), C_nil()); } ast::expr_break. { ret trans_break(e.span, cx); } ast::expr_cont. { ret trans_cont(e.span, cx); } ast::expr_ret(ex) { ret trans_ret(cx, ex); } ast::expr_put(ex) { ret trans_put(cx, ex); } ast::expr_be(ex) { ret trans_be(cx, ex); } ast::expr_anon_obj(anon_obj) { ret trans_anon_obj(cx, e.span, anon_obj, e.id); } _ { // The expression is an lvalue. Fall through. assert (ty::is_lval(e)); // make sure it really is and that we // didn't forget to add a case for a new expr! } } // lval cases fall through to trans_lval and then // possibly load the result (if it's non-structural). let t = ty::expr_ty(bcx_tcx(cx), e); let sub = trans_lval(cx, e); let v = sub.res.val; if sub.is_mem { v = load_if_immediate(sub.res.bcx, v, t); } ret rslt(sub.res.bcx, v); } fn with_out_method(work: fn(&out_method) -> result , cx: @block_ctxt, id: ast::node_id, outer_output: &out_method) -> result { let ccx = bcx_ccx(cx); if outer_output != return { ret work(outer_output); } else { let tp = node_id_type(ccx, id); if ty::type_is_nil(ccx.tcx, tp) { ret work(return); } let res_alloca = alloc_ty(cx, tp); cx = zero_alloca(res_alloca.bcx, res_alloca.val, tp).bcx; fn drop_hoisted_ty(cx: &@block_ctxt, target: ValueRef, t: ty::t) -> result { let reg_val = load_if_immediate(cx, target, t); ret drop_ty(cx, reg_val, t); } let done = work(save_in(res_alloca.val)); let loaded = load_if_immediate(done.bcx, res_alloca.val, tp); add_clean_temp(cx, loaded, tp); ret rslt(done.bcx, loaded); } } // We pass structural values around the compiler "by pointer" and // non-structural values (scalars, boxes, pointers) "by value". We call the // latter group "immediates" and, in some circumstances when we know we have a // pointer (or need one), perform load/store operations based on the // immediate-ness of the type. fn type_is_immediate(ccx: &@crate_ctxt, t: &ty::t) -> bool { ret ty::type_is_scalar(ccx.tcx, t) || ty::type_is_boxed(ccx.tcx, t) || ty::type_is_native(ccx.tcx, t); } fn do_spill(cx: &@block_ctxt, v: ValueRef) -> ValueRef { // We have a value but we have to spill it to pass by alias. let llptr = alloca(cx, val_ty(v)); cx.build.Store(v, llptr); ret llptr; } fn spill_if_immediate(cx: &@block_ctxt, v: ValueRef, t: &ty::t) -> ValueRef { if type_is_immediate(bcx_ccx(cx), t) { ret do_spill(cx, v); } ret v; } fn load_if_immediate(cx: &@block_ctxt, v: ValueRef, t: &ty::t) -> ValueRef { if type_is_immediate(bcx_ccx(cx), t) { ret cx.build.Load(v); } ret v; } fn trans_log(lvl: int, cx: &@block_ctxt, e: &@ast::expr) -> result { let lcx = cx.fcx.lcx; let modname = str::connect(lcx.module_path, "::"); let global; if lcx.ccx.module_data.contains_key(modname) { global = lcx.ccx.module_data.get(modname); } else { let s = link::mangle_internal_name_by_path_and_seq(lcx.ccx, lcx.module_path, "loglevel"); global = llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), str::buf(s)); llvm::LLVMSetGlobalConstant(global, False); llvm::LLVMSetInitializer(global, C_null(T_int())); llvm::LLVMSetLinkage(global, lib::llvm::LLVMInternalLinkage as llvm::Linkage); lcx.ccx.module_data.insert(modname, global); } let log_cx = new_scope_block_ctxt(cx, "log"); let after_cx = new_sub_block_ctxt(cx, "after"); let load = cx.build.Load(global); let test = cx.build.ICmp(lib::llvm::LLVMIntSGE, load, C_int(lvl)); cx.build.CondBr(test, log_cx.llbb, after_cx.llbb); let sub = trans_expr(log_cx, e); let e_ty = ty::expr_ty(bcx_tcx(cx), e); let log_bcx = sub.bcx; let ti = none[@tydesc_info]; let r = get_tydesc(log_bcx, e_ty, false, ti); log_bcx = r.bcx; // Call the polymorphic log function. let llvalptr = spill_if_immediate(log_bcx, sub.val, e_ty); let llval_i8 = log_bcx.build.PointerCast(llvalptr, T_ptr(T_i8())); log_bcx.build.Call(bcx_ccx(log_bcx).upcalls.log_type, ~[log_bcx.fcx.lltaskptr, r.val, llval_i8, C_int(lvl)]); log_bcx = trans_block_cleanups(log_bcx, log_cx); log_bcx.build.Br(after_cx.llbb); ret rslt(after_cx, C_nil()); } fn trans_check_expr(cx: &@block_ctxt, e: &@ast::expr, s: &str) -> result { let cond_res = trans_expr(cx, e); let expr_str = s + " " + expr_to_str(e) + " failed"; let fail_cx = new_sub_block_ctxt(cx, "fail"); trans_fail(fail_cx, some[span](e.span), expr_str); let next_cx = new_sub_block_ctxt(cx, "next"); cond_res.bcx.build.CondBr(cond_res.val, next_cx.llbb, fail_cx.llbb); ret rslt(next_cx, C_nil()); } fn trans_fail_expr(cx: &@block_ctxt, sp_opt: &option::t[span], fail_expr: &option::t[@ast::expr]) -> result { let bcx = cx; alt fail_expr { some(expr) { let tcx = bcx_tcx(bcx); let expr_res = trans_expr(bcx, expr); let e_ty = ty::expr_ty(tcx, expr); bcx = expr_res.bcx; if ty::type_is_str(tcx, e_ty) { let elt = bcx.build.GEP(expr_res.val, ~[C_int(0), C_int(abi::vec_elt_data)]); ret trans_fail_value(bcx, sp_opt, elt); } else { bcx_ccx(cx).sess.span_bug(expr.span, "fail called with unsupported \ type " + ty_to_str(tcx, e_ty)); } } _ { ret trans_fail(bcx, sp_opt, "explicit failure"); } } } fn trans_fail(cx: &@block_ctxt, sp_opt: &option::t[span], fail_str: &str) -> result { let V_fail_str = C_cstr(bcx_ccx(cx), fail_str); ret trans_fail_value(cx, sp_opt, V_fail_str); } fn trans_fail_value(cx: &@block_ctxt, sp_opt: &option::t[span], V_fail_str: &ValueRef) -> result { let V_filename; let V_line; alt sp_opt { some(sp) { let loc = bcx_ccx(cx).sess.lookup_pos(sp.lo); V_filename = C_cstr(bcx_ccx(cx), loc.filename); V_line = loc.line as int; } none. { V_filename = C_cstr(bcx_ccx(cx), ""); V_line = 0; } } let V_str = cx.build.PointerCast(V_fail_str, T_ptr(T_i8())); V_filename = cx.build.PointerCast(V_filename, T_ptr(T_i8())); let args = ~[cx.fcx.lltaskptr, V_str, V_filename, C_int(V_line)]; cx.build.Call(bcx_ccx(cx).upcalls._fail, args); cx.build.Unreachable(); ret rslt(cx, C_nil()); } fn trans_put(cx: &@block_ctxt, e: &option::t[@ast::expr]) -> result { let llcallee = C_nil(); let llenv = C_nil(); alt { cx.fcx.lliterbody } { some(lli) { let slot = alloca(cx, val_ty(lli)); cx.build.Store(lli, slot); llcallee = cx.build.GEP(slot, ~[C_int(0), C_int(abi::fn_field_code)]); llcallee = cx.build.Load(llcallee); llenv = cx.build.GEP(slot, ~[C_int(0), C_int(abi::fn_field_box)]); llenv = cx.build.Load(llenv); } } let bcx = cx; let dummy_retslot = alloca(bcx, T_nil()); let llargs: [ValueRef] = ~[dummy_retslot, cx.fcx.lltaskptr, llenv]; alt e { none. { } some(x) { let e_ty = ty::expr_ty(bcx_tcx(cx), x); let arg = {mode: ty::mo_alias(false), ty: e_ty}; let arg_tys = type_of_explicit_args(bcx_ccx(cx), x.span, ~[arg]); let z = ~[]; let k = ~[]; let r = trans_arg_expr(bcx, arg, arg_tys.(0), z, k, x); bcx = r.bcx; llargs += ~[r.val]; } } bcx.build.FastCall(llcallee, llargs); ret rslt(bcx, C_nil()); } fn trans_break_cont(sp: &span, cx: &@block_ctxt, to_end: bool) -> result { let bcx = cx; // Locate closest loop block, outputting cleanup as we go. let cleanup_cx = cx; while true { bcx = trans_block_cleanups(bcx, cleanup_cx); alt { cleanup_cx.kind } { LOOP_SCOPE_BLOCK(_cont, _break) { if to_end { bcx.build.Br(_break.llbb); } else { alt _cont { option::some(_cont) { bcx.build.Br(_cont.llbb); } _ { bcx.build.Br(cleanup_cx.llbb); } } } ret rslt(new_sub_block_ctxt(bcx, "break_cont.unreachable"), C_nil()); } _ { alt { cleanup_cx.parent } { parent_some(cx) { cleanup_cx = cx; } parent_none. { bcx_ccx(cx).sess.span_fatal(sp, if to_end { "Break" } else { "Cont" } + " outside a loop"); } } } } } // If we get here without returning, it's a bug bcx_ccx(cx).sess.bug("in trans::trans_break_cont()"); } fn trans_break(sp: &span, cx: &@block_ctxt) -> result { ret trans_break_cont(sp, cx, true); } fn trans_cont(sp: &span, cx: &@block_ctxt) -> result { ret trans_break_cont(sp, cx, false); } fn trans_ret(cx: &@block_ctxt, e: &option::t[@ast::expr]) -> result { let bcx = cx; alt e { some(x) { let t = ty::expr_ty(bcx_tcx(cx), x); let lv = trans_lval(cx, x); bcx = lv.res.bcx; bcx = move_val_if_temp(bcx, INIT, cx.fcx.llretptr, lv, t).bcx; } _ { let t = llvm::LLVMGetElementType(val_ty(cx.fcx.llretptr)); bcx.build.Store(C_null(t), cx.fcx.llretptr); } } // run all cleanups and back out. let more_cleanups: bool = true; let cleanup_cx = cx; while more_cleanups { bcx = trans_block_cleanups(bcx, cleanup_cx); alt { cleanup_cx.parent } { parent_some(b) { cleanup_cx = b; } parent_none. { more_cleanups = false; } } } bcx.build.RetVoid(); ret rslt(new_sub_block_ctxt(bcx, "ret.unreachable"), C_nil()); } fn trans_be(cx: &@block_ctxt, e: &@ast::expr) -> result { // FIXME: This should be a typestate precondition assert (ast::is_call_expr(e)); // FIXME: Turn this into a real tail call once // calling convention issues are settled ret trans_ret(cx, some(e)); } fn init_local(bcx: @block_ctxt, local: &@ast::local) -> result { let ty = node_id_type(bcx_ccx(bcx), local.node.id); let llptr = bcx.fcx.lllocals.get(local.node.id); // Make a note to drop this slot on the way out. add_clean(bcx, llptr, ty); alt local.node.init { some(init) { alt init.op { ast::init_assign. { // Use the type of the RHS because if it's _|_, the LHS // type might be something else, but we don't want to copy // the value. ty = node_id_type(bcx_ccx(bcx), init.expr.id); let sub = trans_lval(bcx, init.expr); bcx = move_val_if_temp(sub.res.bcx, INIT, llptr, sub, ty).bcx; } ast::init_move. { let sub = trans_lval(bcx, init.expr); bcx = move_val(sub.res.bcx, INIT, llptr, sub, ty).bcx; } } } _ { bcx = zero_alloca(bcx, llptr, ty).bcx; } } bcx = trans_alt::bind_irrefutable_pat(bcx, local.node.pat, llptr, bcx.fcx.lllocals, false); ret rslt(bcx, llptr); } fn zero_alloca(cx: &@block_ctxt, llptr: ValueRef, t: ty::t) -> result { let bcx = cx; if ty::type_has_dynamic_size(bcx_tcx(cx), t) { let llsz = size_of(bcx, t); let llalign = align_of(llsz.bcx, t); bcx = call_bzero(llalign.bcx, llptr, llsz.val, llalign.val).bcx; } else { let llty = type_of(bcx_ccx(bcx), cx.sp, t); bcx.build.Store(C_null(llty), llptr); } ret rslt(bcx, llptr); } fn trans_stmt(cx: &@block_ctxt, s: &ast::stmt) -> result { // FIXME Fill in cx.sp let bcx = cx; alt s.node { ast::stmt_expr(e, _) { bcx = trans_expr(cx, e).bcx; } ast::stmt_decl(d, _) { alt d.node { ast::decl_local(locals) { for local: @ast::local in locals { bcx = init_local(bcx, local).bcx; } } ast::decl_item(i) { trans_item(cx.fcx.lcx, *i); } } } _ { bcx_ccx(cx).sess.unimpl("stmt variant"); } } ret rslt(bcx, C_nil()); } // You probably don't want to use this one. See the // next three functions instead. fn new_block_ctxt(cx: &@fn_ctxt, parent: &block_parent, kind: block_kind, name: &str) -> @block_ctxt { let cleanups: [cleanup] = ~[]; let s = str::buf(""); let held_name; //HACK for str::buf, which doesn't keep its value alive if cx.lcx.ccx.sess.get_opts().save_temps || cx.lcx.ccx.sess.get_opts().debuginfo { held_name = cx.lcx.ccx.names.next(name); s = str::buf(held_name); } let llbb: BasicBlockRef = llvm::LLVMAppendBasicBlock(cx.llfn, s); ret @{llbb: llbb, build: new_builder(llbb), parent: parent, kind: kind, mutable cleanups: cleanups, sp: cx.sp, fcx: cx}; } // Use this when you're at the top block of a function or the like. fn new_top_block_ctxt(fcx: &@fn_ctxt) -> @block_ctxt { ret new_block_ctxt(fcx, parent_none, SCOPE_BLOCK, "function top level"); } // Use this when you're at a curly-brace or similar lexical scope. fn new_scope_block_ctxt(bcx: &@block_ctxt, n: &str) -> @block_ctxt { ret new_block_ctxt(bcx.fcx, parent_some(bcx), SCOPE_BLOCK, n); } fn new_loop_scope_block_ctxt(bcx: &@block_ctxt, _cont: &option::t[@block_ctxt], _break: &@block_ctxt, n: &str) -> @block_ctxt { ret new_block_ctxt(bcx.fcx, parent_some(bcx), LOOP_SCOPE_BLOCK(_cont, _break), n); } // Use this when you're making a general CFG BB within a scope. fn new_sub_block_ctxt(bcx: &@block_ctxt, n: &str) -> @block_ctxt { ret new_block_ctxt(bcx.fcx, parent_some(bcx), NON_SCOPE_BLOCK, n); } fn new_raw_block_ctxt(fcx: &@fn_ctxt, llbb: BasicBlockRef) -> @block_ctxt { let cleanups: [cleanup] = ~[]; ret @{llbb: llbb, build: new_builder(llbb), parent: parent_none, kind: NON_SCOPE_BLOCK, mutable cleanups: cleanups, sp: fcx.sp, fcx: fcx}; } // trans_block_cleanups: Go through all the cleanups attached to this // block_ctxt and execute them. // // When translating a block that introdces new variables during its scope, we // need to make sure those variables go out of scope when the block ends. We // do that by running a 'cleanup' function for each variable. // trans_block_cleanups runs all the cleanup functions for the block. fn trans_block_cleanups(cx: &@block_ctxt, cleanup_cx: &@block_ctxt) -> @block_ctxt { let bcx = cx; if cleanup_cx.kind == NON_SCOPE_BLOCK { assert (std::ivec::len[cleanup](cleanup_cx.cleanups) == 0u); } let i = std::ivec::len[cleanup](cleanup_cx.cleanups); while i > 0u { i -= 1u; let c = cleanup_cx.cleanups.(i); alt c { clean(cfn) { bcx = cfn(bcx).bcx; } clean_temp(_, cfn) { bcx = cfn(bcx).bcx; } } } ret bcx; } iter block_locals(b: &ast::blk) -> @ast::local { // FIXME: putting from inside an iter block doesn't work, so we can't // use the index here. for s: @ast::stmt in b.node.stmts { alt s.node { ast::stmt_decl(d, _) { alt d.node { ast::decl_local(locals) { for local: @ast::local in locals { put local; } } _ {/* fall through */ } } } _ {/* fall through */ } } } } fn llstaticallocas_block_ctxt(fcx: &@fn_ctxt) -> @block_ctxt { let cleanups: [cleanup] = ~[]; ret @{llbb: fcx.llstaticallocas, build: new_builder(fcx.llstaticallocas), parent: parent_none, kind: SCOPE_BLOCK, mutable cleanups: cleanups, sp: fcx.sp, fcx: fcx}; } fn llderivedtydescs_block_ctxt(fcx: &@fn_ctxt) -> @block_ctxt { let cleanups: [cleanup] = ~[]; ret @{llbb: fcx.llderivedtydescs, build: new_builder(fcx.llderivedtydescs), parent: parent_none, kind: SCOPE_BLOCK, mutable cleanups: cleanups, sp: fcx.sp, fcx: fcx}; } fn lldynamicallocas_block_ctxt(fcx: &@fn_ctxt) -> @block_ctxt { let cleanups: [cleanup] = ~[]; ret @{llbb: fcx.lldynamicallocas, build: new_builder(fcx.lldynamicallocas), parent: parent_none, kind: SCOPE_BLOCK, mutable cleanups: cleanups, sp: fcx.sp, fcx: fcx}; } fn alloc_ty(cx: &@block_ctxt, t: &ty::t) -> result { let bcx = cx; let val = C_int(0); if ty::type_has_dynamic_size(bcx_tcx(bcx), t) { // NB: we have to run this particular 'size_of' in a // block_ctxt built on the llderivedtydescs block for the fn, // so that the size dominates the array_alloca that // comes next. let n = size_of(llderivedtydescs_block_ctxt(bcx.fcx), t); bcx.fcx.llderivedtydescs = n.bcx.llbb; val = array_alloca(bcx, T_i8(), n.val); } else { val = alloca(bcx, type_of(bcx_ccx(cx), cx.sp, t)); } // NB: since we've pushed all size calculations in this // function up to the alloca block, we actually return the // block passed into us unmodified; it doesn't really // have to be passed-and-returned here, but it fits // past caller conventions and may well make sense again, // so we leave it as-is. bcx = gc::add_gc_root(bcx, val, t); ret rslt(cx, val); } fn alloc_local(cx: &@block_ctxt, local: &@ast::local) -> result { let t = node_id_type(bcx_ccx(cx), local.node.id); let r = alloc_ty(cx, t); alt local.node.pat.node { ast::pat_bind(ident) { if bcx_ccx(cx).sess.get_opts().debuginfo { llvm::LLVMSetValueName(r.val, str::buf(ident)); } } _ {} } ret r; } fn trans_block(cx: &@block_ctxt, b: &ast::blk, output: &out_method) -> result { let bcx = cx; for each local: @ast::local in block_locals(b) { // FIXME Update bcx.sp let r = alloc_local(bcx, local); bcx = r.bcx; bcx.fcx.lllocals.insert(local.node.id, r.val); } let r = rslt(bcx, C_nil()); for s: @ast::stmt in b.node.stmts { r = trans_stmt(bcx, *s); bcx = r.bcx; // If we hit a terminator, control won't go any further so // we're in dead-code land. Stop here. if is_terminated(bcx) { ret r; } } fn accept_out_method(expr: &@ast::expr) -> bool { ret alt expr.node { ast::expr_if(_, _, _) { true } ast::expr_alt(_, _) { true } ast::expr_block(_) { true } _ { false } }; } alt b.node.expr { some(e) { let ccx = bcx_ccx(cx); let r_ty = ty::expr_ty(ccx.tcx, e); let pass = output != return && accept_out_method(e); if pass { r = trans_expr_out(bcx, e, output); bcx = r.bcx; if is_terminated(bcx) || ty::type_is_bot(ccx.tcx, r_ty) { ret r; } } else { let lv = trans_lval(bcx, e); r = lv.res; bcx = r.bcx; if is_terminated(bcx) || ty::type_is_bot(ccx.tcx, r_ty) { ret r; } alt output { save_in(target) { // The output method is to save the value at target, // and we didn't pass it to the recursive trans_expr // call. bcx = move_val_if_temp(bcx, INIT, target, lv, r_ty).bcx; r = rslt(bcx, C_nil()); } return. { } } } } none. { r = rslt(bcx, C_nil()); } } bcx = trans_block_cleanups(bcx, find_scope_cx(bcx)); ret rslt(bcx, r.val); } fn new_local_ctxt(ccx: &@crate_ctxt) -> @local_ctxt { let pth: [str] = ~[]; ret @{path: pth, module_path: ~[ccx.link_meta.name], obj_typarams: ~[], obj_fields: ~[], ccx: ccx}; } // Creates the standard quartet of basic blocks: static allocas, copy args, // derived tydescs, and dynamic allocas. fn mk_standard_basic_blocks(llfn: ValueRef) -> {sa: BasicBlockRef, ca: BasicBlockRef, dt: BasicBlockRef, da: BasicBlockRef} { ret {sa: llvm::LLVMAppendBasicBlock(llfn, str::buf("static_allocas")), ca: llvm::LLVMAppendBasicBlock(llfn, str::buf("copy_args")), dt: llvm::LLVMAppendBasicBlock(llfn, str::buf("derived_tydescs")), da: llvm::LLVMAppendBasicBlock(llfn, str::buf("dynamic_allocas"))}; } // NB: must keep 4 fns in sync: // // - type_of_fn_full // - create_llargs_for_fn_args. // - new_fn_ctxt // - trans_args fn new_fn_ctxt_w_id(cx: @local_ctxt, sp: &span, llfndecl: ValueRef, id: ast::node_id) -> @fn_ctxt { let llretptr: ValueRef = llvm::LLVMGetParam(llfndecl, 0u); let lltaskptr: ValueRef = llvm::LLVMGetParam(llfndecl, 1u); let llenv: ValueRef = llvm::LLVMGetParam(llfndecl, 2u); let llargs: hashmap[ast::node_id, ValueRef] = new_int_hash[ValueRef](); let llobjfields: hashmap[ast::node_id, ValueRef] = new_int_hash[ValueRef](); let lllocals: hashmap[ast::node_id, ValueRef] = new_int_hash[ValueRef](); let llupvars: hashmap[ast::node_id, ValueRef] = new_int_hash[ValueRef](); let derived_tydescs = map::mk_hashmap[ty::t, derived_tydesc_info](ty::hash_ty, ty::eq_ty); let llbbs = mk_standard_basic_blocks(llfndecl); ret @{llfn: llfndecl, lltaskptr: lltaskptr, llenv: llenv, llretptr: llretptr, mutable llstaticallocas: llbbs.sa, mutable llcopyargs: llbbs.ca, mutable llderivedtydescs_first: llbbs.dt, mutable llderivedtydescs: llbbs.dt, mutable lldynamicallocas: llbbs.da, mutable llself: none[val_self_pair], mutable lliterbody: none[ValueRef], mutable iterbodyty: none[ty::t], llargs: llargs, llobjfields: llobjfields, lllocals: lllocals, llupvars: llupvars, mutable lltydescs: ~[], derived_tydescs: derived_tydescs, id: id, sp: sp, lcx: cx}; } fn new_fn_ctxt(cx: @local_ctxt, sp: &span, llfndecl: ValueRef) -> @fn_ctxt { be new_fn_ctxt_w_id(cx, sp, llfndecl, -1); } // NB: must keep 4 fns in sync: // // - type_of_fn_full // - create_llargs_for_fn_args. // - new_fn_ctxt // - trans_args // create_llargs_for_fn_args: Creates a mapping from incoming arguments to // allocas created for them. // // When we translate a function, we need to map its incoming arguments to the // spaces that have been created for them (by code in the llallocas field of // the function's fn_ctxt). create_llargs_for_fn_args populates the llargs // field of the fn_ctxt with fn create_llargs_for_fn_args(cx: &@fn_ctxt, proto: ast::proto, ty_self: option::t[ty::t], ret_ty: ty::t, args: &[ast::arg], ty_params: &[ast::ty_param]) { // Skip the implicit arguments 0, 1, and 2. TODO: Pull out 3u and define // it as a constant, since we're using it in several places in trans this // way. let arg_n = 3u; alt ty_self { some(tt) { cx.llself = some[val_self_pair]({v: cx.llenv, t: tt}); } none. { let i = 0u; for tp: ast::ty_param in ty_params { let llarg = llvm::LLVMGetParam(cx.llfn, arg_n); assert (llarg as int != 0); cx.lltydescs += ~[llarg]; arg_n += 1u; i += 1u; } } } // If the function is actually an iter, populate the lliterbody field of // the function context with the ValueRef that we get from // llvm::LLVMGetParam for the iter's body. if proto == ast::proto_iter { cx.iterbodyty = some(ty::mk_iter_body_fn(fcx_tcx(cx), ret_ty)); let llarg = llvm::LLVMGetParam(cx.llfn, arg_n); assert (llarg as int != 0); cx.lliterbody = some[ValueRef](llarg); arg_n += 1u; } // Populate the llargs field of the function context with the ValueRefs // that we get from llvm::LLVMGetParam for each argument. for arg: ast::arg in args { let llarg = llvm::LLVMGetParam(cx.llfn, arg_n); assert (llarg as int != 0); cx.llargs.insert(arg.id, llarg); arg_n += 1u; } } fn copy_args_to_allocas(fcx: @fn_ctxt, args: &[ast::arg], arg_tys: &[ty::arg]) { let bcx = new_raw_block_ctxt(fcx, fcx.llcopyargs); let arg_n: uint = 0u; for aarg: ast::arg in args { if aarg.mode == ast::val { let argval; alt bcx.fcx.llargs.find(aarg.id) { some(x) { argval = x; } _ { bcx_ccx(bcx).sess.span_fatal (aarg.ty.span, "unbound arg ID in copy_args_to_allocas"); } } let a = do_spill(bcx, argval); // Overwrite the llargs entry for this arg with its alloca. bcx.fcx.llargs.insert(aarg.id, a); } arg_n += 1u; } } fn add_cleanups_for_args(bcx: &@block_ctxt, args: &[ast::arg], arg_tys: &[ty::arg]) { let arg_n: uint = 0u; for aarg: ast::arg in args { if aarg.mode == ast::val || aarg.mode == ast::move { let argval; alt bcx.fcx.llargs.find(aarg.id) { some(x) { argval = x; } _ { bcx_ccx(bcx).sess.span_fatal (aarg.ty.span, "unbound arg ID in add_cleanups_for_args"); } } add_clean(bcx, argval, arg_tys.(arg_n).ty); } arg_n += 1u; } } fn is_terminated(cx: &@block_ctxt) -> bool { let inst = llvm::LLVMGetLastInstruction(cx.llbb); ret llvm::LLVMIsATerminatorInst(inst) as int != 0; } fn arg_tys_of_fn(ccx: &@crate_ctxt, id: ast::node_id) -> [ty::arg] { alt ty::struct(ccx.tcx, ty::node_id_to_type(ccx.tcx, id)) { ty::ty_fn(_, arg_tys, _, _, _) { ret arg_tys; } } } fn populate_fn_ctxt_from_llself(fcx: @fn_ctxt, llself: val_self_pair) { let bcx = llstaticallocas_block_ctxt(fcx); let field_tys: [ty::t] = ~[]; for f: ast::obj_field in bcx.fcx.lcx.obj_fields { field_tys += ~[node_id_type(bcx_ccx(bcx), f.id)]; } // Synthesize a tuple type for the fields so that GEP_tup_like() can work // its magic. let fields_tup_ty = ty::mk_tup(fcx.lcx.ccx.tcx, field_tys); let n_typarams = std::ivec::len[ast::ty_param](bcx.fcx.lcx.obj_typarams); let llobj_box_ty: TypeRef = T_obj_ptr(*bcx_ccx(bcx), n_typarams); let box_cell = bcx.build.GEP(llself.v, ~[C_int(0), C_int(abi::obj_field_box)]); let box_ptr = bcx.build.Load(box_cell); box_ptr = bcx.build.PointerCast(box_ptr, llobj_box_ty); let obj_typarams = bcx.build.GEP(box_ptr, ~[C_int(0), C_int(abi::box_rc_field_body), C_int(abi::obj_body_elt_typarams)]); // The object fields immediately follow the type parameters, so we skip // over them to get the pointer. let et = llvm::LLVMGetElementType(val_ty(obj_typarams)); let obj_fields = bcx.build.Add(vp2i(bcx, obj_typarams), llsize_of(et)); // If we can (i.e. the type is statically sized), then cast the resulting // fields pointer to the appropriate LLVM type. If not, just leave it as // i8 *. if !ty::type_has_dynamic_size(fcx.lcx.ccx.tcx, fields_tup_ty) { let llfields_ty = type_of(fcx.lcx.ccx, fcx.sp, fields_tup_ty); obj_fields = vi2p(bcx, obj_fields, T_ptr(llfields_ty)); } else { obj_fields = vi2p(bcx, obj_fields, T_ptr(T_i8())); } let i: int = 0; for p: ast::ty_param in fcx.lcx.obj_typarams { let lltyparam: ValueRef = bcx.build.GEP(obj_typarams, ~[C_int(0), C_int(i)]); lltyparam = bcx.build.Load(lltyparam); fcx.lltydescs += ~[lltyparam]; i += 1; } i = 0; for f: ast::obj_field in fcx.lcx.obj_fields { let rslt = GEP_tup_like(bcx, fields_tup_ty, obj_fields, ~[0, i]); bcx = llstaticallocas_block_ctxt(fcx); let llfield = rslt.val; fcx.llobjfields.insert(f.id, llfield); i += 1; } fcx.llstaticallocas = bcx.llbb; } // Ties up the llstaticallocas -> llcopyargs -> llderivedtydescs -> // lldynamicallocas -> lltop edges. fn finish_fn(fcx: &@fn_ctxt, lltop: BasicBlockRef) { new_builder(fcx.llstaticallocas).Br(fcx.llcopyargs); new_builder(fcx.llcopyargs).Br(fcx.llderivedtydescs_first); new_builder(fcx.llderivedtydescs).Br(fcx.lldynamicallocas); new_builder(fcx.lldynamicallocas).Br(lltop); } // trans_closure: Builds an LLVM function out of a source function. // If the function closes over its environment a closure will be // returned. fn trans_closure(bcx_maybe: &option::t[@block_ctxt], llfnty: &option::t[TypeRef], cx: @local_ctxt, sp: &span, f: &ast::_fn, llfndecl: ValueRef, ty_self: option::t[ty::t], ty_params: &[ast::ty_param], id: ast::node_id) -> option::t[{fn_pair: ValueRef, bcx: @block_ctxt}] { set_uwtable(llfndecl); // Set up arguments to the function. let fcx = new_fn_ctxt_w_id(cx, sp, llfndecl, id); create_llargs_for_fn_args(fcx, f.proto, ty_self, ty::ret_ty_of_fn(cx.ccx.tcx, id), f.decl.inputs, ty_params); alt { fcx.llself } { some(llself) { populate_fn_ctxt_from_llself(fcx, llself); } _ { } } let arg_tys = arg_tys_of_fn(fcx.lcx.ccx, id); copy_args_to_allocas(fcx, f.decl.inputs, arg_tys); // Figure out if we need to build a closure and act accordingly let res = alt f.proto { ast::proto_block. | ast::proto_closure. { let bcx = option::get(bcx_maybe); let upvars = get_freevars(cx.ccx.tcx, id); let copying = f.proto == ast::proto_closure; let env = build_closure(bcx, upvars, copying); load_environment(bcx, fcx, env.ptrty, upvars, copying); let closure = create_real_fn_pair(env.bcx, option::get(llfnty), llfndecl, env.ptr); if copying { add_clean_temp(bcx, closure, node_id_type(cx.ccx, id)) } some({fn_pair: closure, bcx: env.bcx}) } _ { none } }; // Create the first basic block in the function and keep a handle on it to // pass to finish_fn later. let bcx = new_top_block_ctxt(fcx); add_cleanups_for_args(bcx, f.decl.inputs, arg_tys); let lltop = bcx.llbb; let block_ty = node_id_type(cx.ccx, f.body.node.id); if cx.ccx.sess.get_opts().dps { // Call into the new destination-passing-style translation engine. let dest = trans_dps::dest_move(cx.ccx.tcx, fcx.llretptr, block_ty); bcx = trans_dps::trans_block(bcx, dest, f.body); } else { // This call to trans_block is the place where we bridge between // translation calls that don't have a return value (trans_crate, // trans_mod, trans_item, trans_obj, et cetera) and those that do // (trans_block, trans_expr, et cetera). let rslt = if !ty::type_is_nil(cx.ccx.tcx, block_ty) && !ty::type_is_bot(cx.ccx.tcx, block_ty) && f.proto != ast::proto_iter { trans_block(bcx, f.body, save_in(fcx.llretptr)) } else { trans_block(bcx, f.body, return) }; bcx = rslt.bcx; } if !is_terminated(bcx) { // FIXME: until LLVM has a unit type, we are moving around // C_nil values rather than their void type. bcx.build.RetVoid(); } // Insert the mandatory first few basic blocks before lltop. finish_fn(fcx, lltop); ret res; } fn trans_fn_inner(cx: @local_ctxt, sp: &span, f: &ast::_fn, llfndecl: ValueRef, ty_self: option::t[ty::t], ty_params: &[ast::ty_param], id: ast::node_id) { trans_closure(none, none, cx, sp, f, llfndecl, ty_self, ty_params, id); } // trans_fn: creates an LLVM function corresponding to a source language // function. fn trans_fn(cx: @local_ctxt, sp: &span, f: &ast::_fn, llfndecl: ValueRef, ty_self: option::t[ty::t], ty_params: &[ast::ty_param], id: ast::node_id) { if !cx.ccx.sess.get_opts().stats { trans_fn_inner(cx, sp, f, llfndecl, ty_self, ty_params, id); ret; } let start = time::get_time(); trans_fn_inner(cx, sp, f, llfndecl, ty_self, ty_params, id); let end = time::get_time(); log_fn_time(cx.ccx, str::connect(cx.path, "::"), start, end); } fn trans_res_ctor(cx: @local_ctxt, sp: &span, dtor: &ast::_fn, ctor_id: ast::node_id, ty_params: &[ast::ty_param]) { // Create a function for the constructor let llctor_decl; alt cx.ccx.item_ids.find(ctor_id) { some(x) { llctor_decl = x; } _ { cx.ccx.sess.span_fatal(sp, "unbound ctor_id in trans_res_ctor"); } } let fcx = new_fn_ctxt(cx, sp, llctor_decl); let ret_t = ty::ret_ty_of_fn(cx.ccx.tcx, ctor_id); create_llargs_for_fn_args(fcx, ast::proto_fn, none[ty::t], ret_t, dtor.decl.inputs, ty_params); let bcx = new_top_block_ctxt(fcx); let lltop = bcx.llbb; let arg_t = arg_tys_of_fn(cx.ccx, ctor_id).(0).ty; let tup_t = ty::mk_tup(cx.ccx.tcx, ~[ty::mk_int(cx.ccx.tcx), arg_t]); let arg; alt fcx.llargs.find(dtor.decl.inputs.(0).id) { some(x) { arg = load_if_immediate(bcx, x, arg_t); } _ { cx.ccx.sess.span_fatal(sp, "unbound dtor decl in trans_res_ctor"); } } let llretptr = fcx.llretptr; if ty::type_has_dynamic_size(cx.ccx.tcx, ret_t) { let llret_t = T_ptr(T_struct(~[T_i32(), llvm::LLVMTypeOf(arg)])); llretptr = bcx.build.BitCast(llretptr, llret_t); } let dst = GEP_tup_like(bcx, tup_t, llretptr, ~[0, 1]); bcx = dst.bcx; bcx = copy_val(bcx, INIT, dst.val, arg, arg_t).bcx; let flag = GEP_tup_like(bcx, tup_t, llretptr, ~[0, 0]); bcx = flag.bcx; bcx.build.Store(C_int(1), flag.val); bcx.build.RetVoid(); finish_fn(fcx, lltop); } fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id, variant: &ast::variant, index: int, is_degen: bool, ty_params: &[ast::ty_param]) { if std::ivec::len[ast::variant_arg](variant.node.args) == 0u { ret; // nullary constructors are just constants } // Translate variant arguments to function arguments. let fn_args: [ast::arg] = ~[]; let i = 0u; for varg: ast::variant_arg in variant.node.args { fn_args += ~[{mode: ast::alias(false), ty: varg.ty, ident: "arg" + uint::to_str(i, 10u), id: varg.id}]; } assert (cx.ccx.item_ids.contains_key(variant.node.id)); let llfndecl: ValueRef; alt cx.ccx.item_ids.find(variant.node.id) { some(x) { llfndecl = x; } _ { cx.ccx.sess.span_fatal(variant.span, "unbound variant id in trans_tag_variant"); } } let fcx = new_fn_ctxt(cx, variant.span, llfndecl); create_llargs_for_fn_args(fcx, ast::proto_fn, none[ty::t], ty::ret_ty_of_fn(cx.ccx.tcx, variant.node.id), fn_args, ty_params); let ty_param_substs: [ty::t] = ~[]; i = 0u; for tp: ast::ty_param in ty_params { ty_param_substs += ~[ty::mk_param(cx.ccx.tcx, i, tp.kind)]; i += 1u; } let arg_tys = arg_tys_of_fn(cx.ccx, variant.node.id); copy_args_to_allocas(fcx, fn_args, arg_tys); let bcx = new_top_block_ctxt(fcx); let lltop = bcx.llbb; // Cast the tag to a type we can GEP into. let llblobptr = if is_degen { fcx.llretptr } else { let lltagptr = bcx.build.PointerCast(fcx.llretptr, T_opaque_tag_ptr(fcx.lcx.ccx.tn)); let lldiscrimptr = bcx.build.GEP(lltagptr, ~[C_int(0), C_int(0)]); bcx.build.Store(C_int(index), lldiscrimptr); bcx.build.GEP(lltagptr, ~[C_int(0), C_int(1)]) }; i = 0u; for va: ast::variant_arg in variant.node.args { let rslt = GEP_tag(bcx, llblobptr, ast::local_def(tag_id), ast::local_def(variant.node.id), ty_param_substs, i as int); bcx = rslt.bcx; let lldestptr = rslt.val; // If this argument to this function is a tag, it'll have come in to // this function as an opaque blob due to the way that type_of() // works. So we have to cast to the destination's view of the type. let llargptr; alt fcx.llargs.find(va.id) { some(x) { llargptr = bcx.build.PointerCast(x, val_ty(lldestptr)); } none. { bcx_ccx(bcx).sess.bug("unbound argptr in \ trans_tag_variant"); } } let arg_ty = arg_tys.(i).ty; let llargval; if ty::type_is_structural(cx.ccx.tcx, arg_ty) || ty::type_has_dynamic_size(cx.ccx.tcx, arg_ty) { llargval = llargptr; } else { llargval = bcx.build.Load(llargptr); } rslt = copy_val(bcx, INIT, lldestptr, llargval, arg_ty); bcx = rslt.bcx; i += 1u; } bcx = trans_block_cleanups(bcx, find_scope_cx(bcx)); bcx.build.RetVoid(); finish_fn(fcx, lltop); } // FIXME: this should do some structural hash-consing to avoid // duplicate constants. I think. Maybe LLVM has a magical mode // that does so later on? fn trans_const_expr(cx: &@crate_ctxt, e: @ast::expr) -> ValueRef { alt e.node { ast::expr_lit(lit) { ret trans_crate_lit(cx, *lit); } _ { cx.sess.span_unimpl(e.span, "consts that's not a plain literal"); } } } fn trans_const(cx: &@crate_ctxt, e: @ast::expr, id: ast::node_id) { let v = trans_const_expr(cx, e); // The scalars come back as 1st class LLVM vals // which we have to stick into global constants. alt cx.consts.find(id) { some(g) { llvm::LLVMSetInitializer(g, v); llvm::LLVMSetGlobalConstant(g, True); } _ { cx.sess.span_fatal(e.span, "Unbound const in trans_const"); } } } fn trans_item(cx: @local_ctxt, item: &ast::item) { alt item.node { ast::item_fn(f, tps) { let sub_cx = extend_path(cx, item.ident); alt cx.ccx.item_ids.find(item.id) { some(llfndecl) { trans_fn(sub_cx, item.span, f, llfndecl, none, tps, item.id); } _ { cx.ccx.sess.span_fatal(item.span, "unbound function item in trans_item"); } } } ast::item_obj(ob, tps, ctor_id) { let sub_cx = @{obj_typarams: tps, obj_fields: ob.fields with *extend_path(cx, item.ident)}; trans_obj(sub_cx, item.span, ob, ctor_id, tps); } ast::item_res(dtor, dtor_id, tps, ctor_id) { trans_res_ctor(cx, item.span, dtor, ctor_id, tps); // Create a function for the destructor alt cx.ccx.item_ids.find(item.id) { some(lldtor_decl) { trans_fn(cx, item.span, dtor, lldtor_decl, none, tps, dtor_id); } _ { cx.ccx.sess.span_fatal(item.span, "unbound dtor in trans_item"); } } } ast::item_mod(m) { let sub_cx = @{path: cx.path + ~[item.ident], module_path: cx.module_path + ~[item.ident] with *cx}; trans_mod(sub_cx, m); } ast::item_tag(variants, tps) { let sub_cx = extend_path(cx, item.ident); let degen = std::ivec::len(variants) == 1u; let i = 0; for variant: ast::variant in variants { trans_tag_variant(sub_cx, item.id, variant, i, degen, tps); i += 1; } } ast::item_const(_, expr) { trans_const(cx.ccx, expr, item.id); } _ {/* fall through */ } } } // Translate a module. Doing this amounts to translating the items in the // module; there ends up being no artifact (aside from linkage names) of // separate modules in the compiled program. That's because modules exist // only as a convenience for humans working with the code, to organize names // and control visibility. fn trans_mod(cx: @local_ctxt, m: &ast::_mod) { for item: @ast::item in m.items { trans_item(cx, *item); } } fn get_pair_fn_ty(llpairty: TypeRef) -> TypeRef { // Bit of a kludge: pick the fn typeref out of the pair. ret struct_elt(llpairty, 0u); } fn decl_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str], flav: str, ty_params: &[ast::ty_param], node_id: ast::node_id) { decl_fn_and_pair_full(ccx, sp, path, flav, ty_params, node_id, node_id_type(ccx, node_id)); } fn decl_fn_and_pair_full(ccx: &@crate_ctxt, sp: &span, path: &[str], flav: str, ty_params: &[ast::ty_param], node_id: ast::node_id, node_type: ty::t) { let llfty = type_of_fn_from_ty(ccx, sp, node_type, std::ivec::len(ty_params)); alt ty::struct(ccx.tcx, node_type) { ty::ty_fn(proto, inputs, output, _, _) { llfty = type_of_fn(ccx, sp, proto, inputs, output, std::ivec::len[ast::ty_param](ty_params)); } _ { ccx.sess.bug("decl_fn_and_pair(): fn item doesn't have fn type!"); } } let s: str = mangle_internal_name_by_path(ccx, path); let llfn: ValueRef = decl_internal_fastcall_fn(ccx.llmod, s, llfty); // Declare the global constant pair that points to it. let ps: str = mangle_exported_name(ccx, path, node_type); register_fn_pair(ccx, ps, llfty, llfn, node_id); let is_main: bool = is_main_name(path) && !ccx.sess.get_opts().library; if is_main { create_main_wrapper(ccx, sp, llfn, node_type); } } fn create_main_wrapper(ccx: &@crate_ctxt, sp: &span, main_llfn: ValueRef, main_node_type: ty::t) { if ccx.main_fn != none[ValueRef] { ccx.sess.span_fatal(sp, "multiple 'main' functions"); } tag main_mode { mm_nil; mm_vec; mm_ivec; }; let main_mode = alt ty::struct(ccx.tcx, main_node_type) { ty::ty_fn(_, args, _ ,_ ,_) { if std::ivec::len(args) == 0u { mm_nil } else { alt ty::struct(ccx.tcx, args.(0).ty) { ty::ty_ivec(_) { mm_ivec } ty::ty_vec(_) { mm_vec } } } } }; // Have to create two different main functions depending on whether // main was declared to take vec or ivec let llfn_vec = create_main_wrapper_vec(ccx, sp, main_llfn, main_mode); let llfn_ivec = create_main_wrapper_ivec(ccx, sp, main_llfn, main_mode); let takes_ivec = main_mode == mm_ivec; // Create a global to tell main.ll which main we want to use create_main_type_indicator(ccx, takes_ivec); ccx.main_fn = takes_ivec ? some(llfn_ivec) : some(llfn_vec); fn create_main_wrapper_vec(ccx: &@crate_ctxt, sp: &span, main_llfn: ValueRef, main_mode: main_mode) -> ValueRef { let vecarg = { mode: ty::mo_val, ty: ty::mk_vec(ccx.tcx, { ty: ty::mk_str(ccx.tcx), mut: ast::imm }) }; let llfty = type_of_fn(ccx, sp, ast::proto_fn, ~[vecarg], ty::mk_nil(ccx.tcx), 0u); let llfdecl = decl_fastcall_fn(ccx.llmod, "_rust_main", llfty); let fcx = new_fn_ctxt(new_local_ctxt(ccx), sp, llfdecl); let bcx = new_top_block_ctxt(fcx); if main_mode != mm_ivec { let lloutputarg = llvm::LLVMGetParam(llfdecl, 0u); let lltaskarg = llvm::LLVMGetParam(llfdecl, 1u); let llenvarg = llvm::LLVMGetParam(llfdecl, 2u); let llargvarg = llvm::LLVMGetParam(llfdecl, 3u); let args = alt main_mode { mm_nil. { ~[lloutputarg, lltaskarg, llenvarg] } mm_vec. { ~[lloutputarg, lltaskarg, llenvarg, llargvarg] } }; bcx.build.FastCall(main_llfn, args); } bcx.build.RetVoid(); let lltop = bcx.llbb; finish_fn(fcx, lltop); ret llfdecl; } fn create_main_wrapper_ivec(ccx: &@crate_ctxt, sp: &span, main_llfn: ValueRef, main_mode: main_mode) -> ValueRef { let ivecarg = { mode: ty::mo_val, ty: ty::mk_ivec(ccx.tcx, { ty: ty::mk_str(ccx.tcx), mut: ast::imm }) }; let llfty = type_of_fn(ccx, sp, ast::proto_fn, ~[ivecarg], ty::mk_nil(ccx.tcx), 0u); let llfdecl = decl_fastcall_fn(ccx.llmod, "_rust_main_ivec", llfty); let fcx = new_fn_ctxt(new_local_ctxt(ccx), sp, llfdecl); let bcx = new_top_block_ctxt(fcx); if main_mode == mm_ivec { let lloutputarg = llvm::LLVMGetParam(llfdecl, 0u); let lltaskarg = llvm::LLVMGetParam(llfdecl, 1u); let llenvarg = llvm::LLVMGetParam(llfdecl, 2u); let llargvarg = llvm::LLVMGetParam(llfdecl, 3u); let args = ~[lloutputarg, lltaskarg, llenvarg, llargvarg]; bcx.build.FastCall(main_llfn, args); } bcx.build.RetVoid(); let lltop = bcx.llbb; finish_fn(fcx, lltop); ret llfdecl; } // FIXME: Remove after main takes only ivec // Sets a global value hinting to the runtime whether main takes // a vec or an ivec fn create_main_type_indicator(ccx: &@crate_ctxt, takes_ivec: bool) { let i = llvm::LLVMAddGlobal(ccx.llmod, T_int(), str::buf("_rust_main_is_ivec")); llvm::LLVMSetInitializer(i, C_int(takes_ivec as int)); llvm::LLVMSetGlobalConstant(i, True); } } // Create a closure: a pair containing (1) a ValueRef, pointing to where the // fn's definition is in the executable we're creating, and (2) a pointer to // space for the function's environment. fn create_fn_pair(cx: &@crate_ctxt, ps: str, llfnty: TypeRef, llfn: ValueRef, external: bool) -> ValueRef { let gvar = llvm::LLVMAddGlobal(cx.llmod, T_fn_pair(*cx, llfnty), str::buf(ps)); let pair = C_struct(~[llfn, C_null(T_opaque_closure_ptr(*cx))]); llvm::LLVMSetInitializer(gvar, pair); llvm::LLVMSetGlobalConstant(gvar, True); if !external { llvm::LLVMSetLinkage(gvar, lib::llvm::LLVMInternalLinkage as llvm::Linkage); } ret gvar; } // Create a /real/ closure: this is like create_fn_pair, but creates a // a fn value on the stack with a specified environment (which need not be // on the stack). fn create_real_fn_pair(cx: &@block_ctxt, llfnty: TypeRef, llfn: ValueRef, llenvptr: ValueRef) -> ValueRef { let lcx = cx.fcx.lcx; let pair = alloca(cx, T_fn_pair(*lcx.ccx, llfnty)); let code_cell = cx.build.GEP(pair, ~[C_int(0), C_int(abi::fn_field_code)]); cx.build.Store(llfn, code_cell); let env_cell = cx.build.GEP(pair, ~[C_int(0), C_int(abi::fn_field_box)]); let llenvblobptr = cx.build.PointerCast(llenvptr, T_opaque_closure_ptr(*lcx.ccx)); cx.build.Store(llenvblobptr, env_cell); ret pair; } fn register_fn_pair(cx: &@crate_ctxt, ps: str, llfnty: TypeRef, llfn: ValueRef, id: ast::node_id) { // FIXME: We should also hide the unexported pairs in crates. let gvar = create_fn_pair(cx, ps, llfnty, llfn, cx.sess.get_opts().library); cx.item_ids.insert(id, llfn); cx.item_symbols.insert(id, ps); cx.fn_pairs.insert(id, gvar); } // Returns the number of type parameters that the given native function has. fn native_fn_ty_param_count(cx: &@crate_ctxt, id: ast::node_id) -> uint { let count; let native_item = alt cx.ast_map.find(id) { some(ast_map::node_native_item(i)) { i } }; alt native_item.node { ast::native_item_ty. { cx.sess.bug("decl_native_fn_and_pair(): native fn isn't \ actually a fn"); } ast::native_item_fn(_, _, tps) { count = std::ivec::len[ast::ty_param](tps); } } ret count; } fn native_fn_wrapper_type(cx: &@crate_ctxt, sp: &span, ty_param_count: uint, x: ty::t) -> TypeRef { alt ty::struct(cx.tcx, x) { ty::ty_native_fn(abi, args, out) { ret type_of_fn(cx, sp, ast::proto_fn, args, out, ty_param_count); } } } fn decl_native_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str], name: str, id: ast::node_id) { let num_ty_param = native_fn_ty_param_count(ccx, id); // Declare the wrapper. let t = node_id_type(ccx, id); let wrapper_type = native_fn_wrapper_type(ccx, sp, num_ty_param, t); let s: str = mangle_internal_name_by_path(ccx, path); let wrapper_fn: ValueRef = decl_internal_fastcall_fn(ccx.llmod, s, wrapper_type); // Declare the global constant pair that points to it. let ps: str = mangle_exported_name(ccx, path, node_id_type(ccx, id)); register_fn_pair(ccx, ps, wrapper_type, wrapper_fn, id); // Build the wrapper. let fcx = new_fn_ctxt(new_local_ctxt(ccx), sp, wrapper_fn); let bcx = new_top_block_ctxt(fcx); let lltop = bcx.llbb; // Declare the function itself. let fn_type = node_id_type(ccx, id); // NB: has no type params let abi = ty::ty_fn_abi(ccx.tcx, fn_type); // FIXME: If the returned type is not nil, then we assume it's 32 bits // wide. This is obviously wildly unsafe. We should have a better FFI // that allows types of different sizes to be returned. let rty = ty::ty_fn_ret(ccx.tcx, fn_type); let rty_is_nil = ty::type_is_nil(ccx.tcx, rty); let pass_task; let uses_retptr; let cast_to_i32; alt abi { ast::native_abi_rust. { pass_task = true; uses_retptr = false; cast_to_i32 = true; } ast::native_abi_rust_intrinsic. { pass_task = true; uses_retptr = true; cast_to_i32 = false; } ast::native_abi_cdecl. { pass_task = false; uses_retptr = false; cast_to_i32 = true; } ast::native_abi_llvm. { pass_task = false; uses_retptr = false; cast_to_i32 = false; } ast::native_abi_x86stdcall. { pass_task = false; uses_retptr = false; cast_to_i32 = true; } } let lltaskptr; if cast_to_i32 { lltaskptr = vp2i(bcx, fcx.lltaskptr); } else { lltaskptr = fcx.lltaskptr; } let call_args: [ValueRef] = ~[]; if pass_task { call_args += ~[lltaskptr]; } if uses_retptr { call_args += ~[bcx.fcx.llretptr]; } let arg_n = 3u; for each i: uint in uint::range(0u, num_ty_param) { let llarg = llvm::LLVMGetParam(fcx.llfn, arg_n); fcx.lltydescs += ~[llarg]; assert (llarg as int != 0); if cast_to_i32 { call_args += ~[vp2i(bcx, llarg)]; } else { call_args += ~[llarg]; } arg_n += 1u; } fn convert_arg_to_i32(cx: &@block_ctxt, v: ValueRef, t: ty::t, mode: ty::mode) -> ValueRef { if mode == ty::mo_val { if ty::type_is_integral(bcx_tcx(cx), t) { let lldsttype = T_int(); let llsrctype = type_of(bcx_ccx(cx), cx.sp, t); if llvm::LLVMGetIntTypeWidth(lldsttype) > llvm::LLVMGetIntTypeWidth(llsrctype) { ret cx.build.ZExtOrBitCast(v, T_int()); } ret cx.build.TruncOrBitCast(v, T_int()); } if ty::type_is_fp(bcx_tcx(cx), t) { ret cx.build.FPToSI(v, T_int()); } } ret vp2i(cx, v); } fn trans_simple_native_abi(bcx: &@block_ctxt, name: str, call_args: &mutable [ValueRef], fn_type: ty::t, first_arg_n: uint, uses_retptr: bool, cc: uint) -> {val: ValueRef, rptr: ValueRef} { let call_arg_tys: [TypeRef] = ~[]; for arg: ValueRef in call_args { call_arg_tys += ~[val_ty(arg)]; } let llnativefnty; if uses_retptr { llnativefnty = T_fn(call_arg_tys, T_void()); } else { llnativefnty = T_fn(call_arg_tys, type_of(bcx_ccx(bcx), bcx.sp, ty::ty_fn_ret(bcx_tcx(bcx), fn_type))); } let llnativefn = get_extern_fn(bcx_ccx(bcx).externs, bcx_ccx(bcx).llmod, name, cc, llnativefnty); let r = if cc == lib::llvm::LLVMCCallConv { bcx.build.Call(llnativefn, call_args) } else { bcx.build.CallWithConv(llnativefn, call_args, cc) }; let rptr = bcx.fcx.llretptr; ret {val: r, rptr: rptr}; } let args = ty::ty_fn_args(ccx.tcx, fn_type); // Build up the list of arguments. let drop_args: [{val: ValueRef, ty: ty::t}] = ~[]; let i = arg_n; for arg: ty::arg in args { let llarg = llvm::LLVMGetParam(fcx.llfn, i); assert (llarg as int != 0); if cast_to_i32 { let llarg_i32 = convert_arg_to_i32(bcx, llarg, arg.ty, arg.mode); call_args += ~[llarg_i32]; } else { call_args += ~[llarg]; } if arg.mode == ty::mo_val { drop_args += ~[{val: llarg, ty: arg.ty}]; } i += 1u; } let r; let rptr; alt abi { ast::native_abi_llvm. { let result = trans_simple_native_abi(bcx, name, call_args, fn_type, arg_n, uses_retptr, lib::llvm::LLVMCCallConv); r = result.val; rptr = result.rptr; } ast::native_abi_rust_intrinsic. { let external_name = "rust_intrinsic_" + name; let result = trans_simple_native_abi(bcx, external_name, call_args, fn_type, arg_n, uses_retptr, lib::llvm::LLVMCCallConv); r = result.val; rptr = result.rptr; } ast::native_abi_x86stdcall. { let result = trans_simple_native_abi(bcx, name, call_args, fn_type, arg_n, uses_retptr, lib::llvm::LLVMX86StdcallCallConv); r = result.val; rptr = result.rptr; } _ { r = trans_native_call(bcx.build, ccx.glues, lltaskptr, ccx.externs, ccx.tn, ccx.llmod, name, pass_task, call_args); rptr = bcx.build.BitCast(fcx.llretptr, T_ptr(T_i32())); } } // We don't store the return value if it's nil, to avoid stomping on a nil // pointer. This is the only concession made to non-i32 return values. See // the FIXME above. if !rty_is_nil && !uses_retptr { bcx.build.Store(r, rptr); } for d: {val: ValueRef, ty: ty::t} in drop_args { bcx = drop_ty(bcx, d.val, d.ty).bcx; } bcx.build.RetVoid(); finish_fn(fcx, lltop); } fn item_path(item: &@ast::item) -> [str] { ret ~[item.ident]; } fn collect_native_item(ccx: @crate_ctxt, i: &@ast::native_item, pt: &[str], v: &vt[[str]]) { alt i.node { ast::native_item_fn(_, _, _) { if !ccx.obj_methods.contains_key(i.id) { decl_native_fn_and_pair(ccx, i.span, pt, i.ident, i.id); } } _ { } } } fn collect_item_1(ccx: @crate_ctxt, i: &@ast::item, pt: &[str], v: &vt[[str]]) { visit::visit_item(i, pt + item_path(i), v); alt i.node { ast::item_const(_, _) { let typ = node_id_type(ccx, i.id); let s = mangle_exported_name(ccx, pt + ~[i.ident], node_id_type(ccx, i.id)); let g = llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, i.span, typ), str::buf(s)); ccx.item_symbols.insert(i.id, s); ccx.consts.insert(i.id, g); } _ { } } } fn collect_item_2(ccx: &@crate_ctxt, i: &@ast::item, pt: &[str], v: &vt[[str]]) { let new_pt = pt + item_path(i); visit::visit_item(i, new_pt, v); alt i.node { ast::item_fn(f, tps) { if !ccx.obj_methods.contains_key(i.id) { decl_fn_and_pair(ccx, i.span, new_pt, "fn", tps, i.id); } } ast::item_obj(ob, tps, ctor_id) { decl_fn_and_pair(ccx, i.span, new_pt, "obj_ctor", tps, ctor_id); for m: @ast::method in ob.methods { ccx.obj_methods.insert(m.node.id, ()); } } ast::item_res(_, dtor_id, tps, ctor_id) { decl_fn_and_pair(ccx, i.span, new_pt, "res_ctor", tps, ctor_id); // Note that the destructor is associated with the item's id, not // the dtor_id. This is a bit counter-intuitive, but simplifies // ty_res, which would have to carry around two def_ids otherwise // -- one to identify the type, and one to find the dtor symbol. decl_fn_and_pair_full(ccx, i.span, new_pt, "res_dtor", tps, i.id, node_id_type(ccx, dtor_id)); } _ { } } } fn collect_items(ccx: &@crate_ctxt, crate: @ast::crate) { let visitor0 = visit::default_visitor(); let visitor1 = @{visit_native_item: bind collect_native_item(ccx, _, _, _), visit_item: bind collect_item_1(ccx, _, _, _) with *visitor0}; let visitor2 = @{visit_item: bind collect_item_2(ccx, _, _, _) with *visitor0}; visit::visit_crate(*crate, ~[], visit::mk_vt(visitor1)); visit::visit_crate(*crate, ~[], visit::mk_vt(visitor2)); } fn collect_tag_ctor(ccx: @crate_ctxt, i: &@ast::item, pt: &[str], v: &vt[[str]]) { let new_pt = pt + item_path(i); visit::visit_item(i, new_pt, v); alt i.node { ast::item_tag(variants, tps) { for variant: ast::variant in variants { if std::ivec::len(variant.node.args) != 0u { decl_fn_and_pair(ccx, i.span, new_pt + ~[variant.node.name], "tag", tps, variant.node.id); } } } _ {/* fall through */ } } } fn collect_tag_ctors(ccx: &@crate_ctxt, crate: @ast::crate) { let visitor = @{visit_item: bind collect_tag_ctor(ccx, _, _, _) with *visit::default_visitor()}; visit::visit_crate(*crate, ~[], visit::mk_vt(visitor)); } // The constant translation pass. fn trans_constant(ccx: @crate_ctxt, it: &@ast::item, pt: &[str], v: &vt[[str]]) { let new_pt = pt + item_path(it); visit::visit_item(it, new_pt, v); alt it.node { ast::item_tag(variants, _) { let i = 0u; let n_variants = std::ivec::len[ast::variant](variants); while i < n_variants { let variant = variants.(i); let p = new_pt + ~[it.ident, variant.node.name, "discrim"]; let s = mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx)); let discrim_gvar = llvm::LLVMAddGlobal(ccx.llmod, T_int(), str::buf(s)); if n_variants != 1u { llvm::LLVMSetInitializer(discrim_gvar, C_int(i as int)); llvm::LLVMSetGlobalConstant(discrim_gvar, True); } ccx.discrims.insert(variant.node.id, discrim_gvar); ccx.discrim_symbols.insert(variant.node.id, s); i += 1u; } } _ { } } } fn trans_constants(ccx: &@crate_ctxt, crate: @ast::crate) { let visitor = @{visit_item: bind trans_constant(ccx, _, _, _) with *visit::default_visitor()}; visit::visit_crate(*crate, ~[], visit::mk_vt(visitor)); } fn vp2i(cx: &@block_ctxt, v: ValueRef) -> ValueRef { ret cx.build.PtrToInt(v, T_int()); } fn vi2p(cx: &@block_ctxt, v: ValueRef, t: TypeRef) -> ValueRef { ret cx.build.IntToPtr(v, t); } fn p2i(v: ValueRef) -> ValueRef { ret llvm::LLVMConstPtrToInt(v, T_int()); } fn i2p(v: ValueRef, t: TypeRef) -> ValueRef { ret llvm::LLVMConstIntToPtr(v, t); } fn declare_intrinsics(llmod: ModuleRef) -> hashmap[str, ValueRef] { let T_memmove32_args: [TypeRef] = ~[T_ptr(T_i8()), T_ptr(T_i8()), T_i32(), T_i32(), T_i1()]; let T_memmove64_args: [TypeRef] = ~[T_ptr(T_i8()), T_ptr(T_i8()), T_i64(), T_i32(), T_i1()]; let T_memset32_args: [TypeRef] = ~[T_ptr(T_i8()), T_i8(), T_i32(), T_i32(), T_i1()]; let T_memset64_args: [TypeRef] = ~[T_ptr(T_i8()), T_i8(), T_i64(), T_i32(), T_i1()]; let T_trap_args: [TypeRef] = ~[]; let gcread = decl_cdecl_fn(llmod, "llvm.gcread", T_fn(~[T_ptr(T_i8()), T_ptr(T_ptr(T_i8()))], T_void())); let memmove32 = decl_cdecl_fn(llmod, "llvm.memmove.p0i8.p0i8.i32", T_fn(T_memmove32_args, T_void())); let memmove64 = decl_cdecl_fn(llmod, "llvm.memmove.p0i8.p0i8.i64", T_fn(T_memmove64_args, T_void())); let memset32 = decl_cdecl_fn(llmod, "llvm.memset.p0i8.i32", T_fn(T_memset32_args, T_void())); let memset64 = decl_cdecl_fn(llmod, "llvm.memset.p0i8.i64", T_fn(T_memset64_args, T_void())); let trap = decl_cdecl_fn(llmod, "llvm.trap", T_fn(T_trap_args, T_void())); let intrinsics = new_str_hash[ValueRef](); intrinsics.insert("llvm.gcread", gcread); intrinsics.insert("llvm.memmove.p0i8.p0i8.i32", memmove32); intrinsics.insert("llvm.memmove.p0i8.p0i8.i64", memmove64); intrinsics.insert("llvm.memset.p0i8.i32", memset32); intrinsics.insert("llvm.memset.p0i8.i64", memset64); intrinsics.insert("llvm.trap", trap); ret intrinsics; } fn trap(bcx: &@block_ctxt) { let v: [ValueRef] = ~[]; alt bcx_ccx(bcx).intrinsics.find("llvm.trap") { some(x) { bcx.build.Call(x, v); } _ { bcx_ccx(bcx).sess.bug("unbound llvm.trap in trap"); } } } fn decl_no_op_type_glue(llmod: ModuleRef, taskptr_type: TypeRef) -> ValueRef { let ty = T_fn(~[taskptr_type, T_ptr(T_i8())], T_void()); ret decl_fastcall_fn(llmod, abi::no_op_type_glue_name(), ty); } fn make_no_op_type_glue(fun: ValueRef) { let bb_name = str::buf("_rust_no_op_type_glue_bb"); let llbb = llvm::LLVMAppendBasicBlock(fun, bb_name); new_builder(llbb).RetVoid(); } fn vec_fill(bcx: &@block_ctxt, v: ValueRef) -> ValueRef { ret bcx.build.Load(bcx.build.GEP(v, ~[C_int(0), C_int(abi::vec_elt_fill)])); } fn vec_p0(bcx: &@block_ctxt, v: ValueRef) -> ValueRef { let p = bcx.build.GEP(v, ~[C_int(0), C_int(abi::vec_elt_data)]); ret bcx.build.PointerCast(p, T_ptr(T_i8())); } fn make_glues(llmod: ModuleRef, taskptr_type: TypeRef) -> @glue_fns { ret @{no_op_type_glue: decl_no_op_type_glue(llmod, taskptr_type)}; } fn make_common_glue(sess: &session::session, output: &str) { // FIXME: part of this is repetitive and is probably a good idea // to autogen it. let task_type = T_task(); let taskptr_type = T_ptr(task_type); let llmod = llvm::LLVMModuleCreateWithNameInContext(str::buf("rust_out"), llvm::LLVMGetGlobalContext()); let dat_layt = x86::get_data_layout(); //HACK (buf lifetime issue) llvm::LLVMSetDataLayout(llmod, str::buf(dat_layt)); let targ_trip = x86::get_target_triple(); //HACK (buf lifetime issue) llvm::LLVMSetTarget(llmod, str::buf(targ_trip)); mk_target_data(x86::get_data_layout()); declare_intrinsics(llmod); let modl_asm = x86::get_module_asm(); //HACK (buf lifetime issue) llvm::LLVMSetModuleInlineAsm(llmod, str::buf(modl_asm)); make_glues(llmod, taskptr_type); link::write::run_passes(sess, llmod, output); } fn create_module_map(ccx: &@crate_ctxt) -> ValueRef { let elttype = T_struct(~[T_int(), T_int()]); let maptype = T_array(elttype, ccx.module_data.size() + 1u); let map = llvm::LLVMAddGlobal(ccx.llmod, maptype, str::buf("_rust_mod_map")); llvm::LLVMSetLinkage(map, lib::llvm::LLVMInternalLinkage as llvm::Linkage); let elts: [ValueRef] = ~[]; for each item: @{key: str, val: ValueRef} in ccx.module_data.items() { let elt = C_struct(~[p2i(C_cstr(ccx, item.key)), p2i(item.val)]); elts += ~[elt]; } let term = C_struct(~[C_int(0), C_int(0)]); elts += ~[term]; llvm::LLVMSetInitializer(map, C_array(elttype, elts)); ret map; } // FIXME use hashed metadata instead of crate names once we have that fn create_crate_map(ccx: &@crate_ctxt) -> ValueRef { let subcrates: [ValueRef] = ~[]; let i = 1; let cstore = ccx.sess.get_cstore(); while cstore::have_crate_data(cstore, i) { let nm = "_rust_crate_map_" + cstore::get_crate_data(cstore, i).name; let cr = llvm::LLVMAddGlobal(ccx.llmod, T_int(), str::buf(nm)); subcrates += ~[p2i(cr)]; i += 1; } subcrates += ~[C_int(0)]; let mapname; if ccx.sess.get_opts().library { mapname = ccx.link_meta.name; } else { mapname = "toplevel"; } let sym_name = "_rust_crate_map_" + mapname; let arrtype = T_array(T_int(), std::ivec::len[ValueRef](subcrates)); let maptype = T_struct(~[T_int(), arrtype]); let map = llvm::LLVMAddGlobal(ccx.llmod, maptype, str::buf(sym_name)); llvm::LLVMSetLinkage(map, lib::llvm::LLVMExternalLinkage as llvm::Linkage); llvm::LLVMSetInitializer(map, C_struct(~[p2i(create_module_map(ccx)), C_array(T_int(), subcrates)])); ret map; } fn write_metadata(cx: &@crate_ctxt, crate: &@ast::crate) { if !cx.sess.get_opts().library { ret; } let llmeta = C_postr(metadata::encoder::encode_metadata(cx, crate)); let llconst = trans_common::C_struct(~[llmeta]); let llglobal = llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst), str::buf("rust_metadata")); llvm::LLVMSetInitializer(llglobal, llconst); let met_sct_nm = x86::get_meta_sect_name(); //HACK (buf lifetime issue) llvm::LLVMSetSection(llglobal, str::buf(met_sct_nm)); llvm::LLVMSetLinkage(llglobal, lib::llvm::LLVMInternalLinkage as llvm::Linkage); let t_ptr_i8 = T_ptr(T_i8()); llglobal = llvm::LLVMConstBitCast(llglobal, t_ptr_i8); let llvm_used = llvm::LLVMAddGlobal(cx.llmod, T_array(t_ptr_i8, 1u), str::buf("llvm.used")); llvm::LLVMSetLinkage(llvm_used, lib::llvm::LLVMAppendingLinkage as llvm::Linkage); llvm::LLVMSetInitializer(llvm_used, C_array(t_ptr_i8, ~[llglobal])); } fn trans_crate(sess: &session::session, crate: &@ast::crate, tcx: &ty::ctxt, output: &str, amap: &ast_map::map) -> ModuleRef { let llmod = llvm::LLVMModuleCreateWithNameInContext(str::buf("rust_out"), llvm::LLVMGetGlobalContext()); let dat_layt = x86::get_data_layout(); //HACK (buf lifetime issue) llvm::LLVMSetDataLayout(llmod, str::buf(dat_layt)); let targ_trip = x86::get_target_triple(); //HACK (buf lifetime issue) llvm::LLVMSetTarget(llmod, str::buf(targ_trip)); let td = mk_target_data(dat_layt); let tn = mk_type_names(); let intrinsics = declare_intrinsics(llmod); let task_type = T_task(); let taskptr_type = T_ptr(task_type); tn.associate("taskptr", taskptr_type); let tydesc_type = T_tydesc(taskptr_type); tn.associate("tydesc", tydesc_type); let glues = make_glues(llmod, taskptr_type); let hasher = ty::hash_ty; let eqer = ty::eq_ty; let tag_sizes = map::mk_hashmap[ty::t, uint](hasher, eqer); let tydescs = map::mk_hashmap[ty::t, @tydesc_info](hasher, eqer); let lltypes = map::mk_hashmap[ty::t, TypeRef](hasher, eqer); let sha1s = map::mk_hashmap[ty::t, str](hasher, eqer); let short_names = map::mk_hashmap[ty::t, str](hasher, eqer); let sha = std::sha1::mk_sha1(); let ccx = @{sess: sess, llmod: llmod, td: td, tn: tn, externs: new_str_hash[ValueRef](), intrinsics: intrinsics, item_ids: new_int_hash[ValueRef](), ast_map: amap, item_symbols: new_int_hash[str](), mutable main_fn: none[ValueRef], link_meta: link::build_link_meta(sess, *crate, output, sha), tag_sizes: tag_sizes, discrims: new_int_hash[ValueRef](), discrim_symbols: new_int_hash[str](), fn_pairs: new_int_hash[ValueRef](), consts: new_int_hash[ValueRef](), obj_methods: new_int_hash[()](), tydescs: tydescs, module_data: new_str_hash[ValueRef](), lltypes: lltypes, glues: glues, names: namegen(0), sha: sha, type_sha1s: sha1s, type_short_names: short_names, tcx: tcx, stats: {mutable n_static_tydescs: 0u, mutable n_derived_tydescs: 0u, mutable n_glues_created: 0u, mutable n_null_glues: 0u, mutable n_real_glues: 0u, fn_times: @mutable ~[]}, upcalls: upcall::declare_upcalls(tn, tydesc_type, taskptr_type, llmod), rust_object_type: T_rust_object(), tydesc_type: tydesc_type, task_type: task_type, shape_cx: shape::mk_ctxt(llmod)}; let cx = new_local_ctxt(ccx); collect_items(ccx, crate); collect_tag_ctors(ccx, crate); trans_constants(ccx, crate); trans_mod(cx, crate.node.module); create_crate_map(ccx); emit_tydescs(ccx); shape::gen_shape_tables(ccx); // Translate the metadata. write_metadata(cx.ccx, crate); if ccx.sess.get_opts().stats { log_err "--- trans stats ---"; log_err #fmt("n_static_tydescs: %u", ccx.stats.n_static_tydescs); log_err #fmt("n_derived_tydescs: %u", ccx.stats.n_derived_tydescs); log_err #fmt("n_glues_created: %u", ccx.stats.n_glues_created); log_err #fmt("n_null_glues: %u", ccx.stats.n_null_glues); log_err #fmt("n_real_glues: %u", ccx.stats.n_real_glues); for timing: {ident: str, time: int} in *ccx.stats.fn_times { log_err #fmt("time: %s took %d ms", timing.ident, timing.time); } } ret llmod; } // // Local Variables: // mode: rust // fill-column: 78; // indent-tabs-mode: nil // c-basic-offset: 4 // buffer-file-coding-system: utf-8-unix // compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'"; // End: //