diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs index 6007bd9eea13..0e4f957b5ba5 100644 --- a/src/comp/back/link.rs +++ b/src/comp/back/link.rs @@ -91,7 +91,7 @@ mod write { if opts.time_llvm_passes { llvm::LLVMRustEnableTimePasses(); } link_intrinsics(sess, llmod); let pm = mk_pass_manager(); - let td = mk_target_data(istr::to_estr(x86::get_data_layout())); + let td = mk_target_data(x86::get_data_layout()); llvm::LLVMAddTargetData(td.lltd, pm.llpm); // TODO: run the linter here also, once there are llvm-c bindings for // it. diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs index a090f7cc6675..9bc7dc932f53 100644 --- a/src/comp/lib/llvm.rs +++ b/src/comp/lib/llvm.rs @@ -899,26 +899,26 @@ native "cdecl" mod llvm = "rustllvm" { /* Memory-managed object interface to type handles. */ -obj type_names(type_names: std::map::hashmap, +obj type_names(type_names: std::map::hashmap, named_types: std::map::hashmap) { - fn associate(s: str, t: TypeRef) { - assert (!named_types.contains_key(istr::from_estr(s))); + fn associate(s: &istr, t: TypeRef) { + assert (!named_types.contains_key(s)); assert (!type_names.contains_key(t)); type_names.insert(t, s); - named_types.insert(istr::from_estr(s), t); + named_types.insert(s, t); } fn type_has_name(t: TypeRef) -> bool { ret type_names.contains_key(t); } - fn get_name(t: TypeRef) -> str { ret type_names.get(t); } + fn get_name(t: TypeRef) -> istr { ret type_names.get(t); } - fn name_has_type(s: str) -> bool { - ret named_types.contains_key(istr::from_estr(s)); + fn name_has_type(s: &istr) -> bool { + ret named_types.contains_key(s); } - fn get_type(s: str) -> TypeRef { - ret named_types.get(istr::from_estr(s)); + fn get_type(s: &istr) -> TypeRef { + ret named_types.get(s); } } @@ -931,17 +931,17 @@ fn mk_type_names() -> type_names { let hasher: std::map::hashfn = hash; let eqer: std::map::eqfn = eq; - let tn = std::map::mk_hashmap::(hasher, eqer); + let tn = std::map::mk_hashmap::(hasher, eqer); ret type_names(tn, nt); } -fn type_to_str(names: type_names, ty: TypeRef) -> str { +fn type_to_str(names: type_names, ty: TypeRef) -> istr { ret type_to_str_inner(names, [], ty); } fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) -> - str { + istr { if names.type_has_name(ty) { ret names.get_name(ty); } @@ -949,11 +949,12 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) -> let kind: int = llvm::LLVMGetTypeKind(ty); - fn tys_str(names: type_names, outer: &[TypeRef], tys: &[TypeRef]) -> str { - let s: str = ""; + fn tys_str(names: type_names, outer: &[TypeRef], + tys: &[TypeRef]) -> istr { + let s: istr = ~""; let first: bool = true; for t: TypeRef in tys { - if first { first = false; } else { s += ", "; } + if first { first = false; } else { s += ~", "; } s += type_to_str_inner(names, outer, t); } ret s; @@ -968,32 +969,32 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) -> // horrible, horrible. Complete as needed. 0 { - ret "Void"; + ret ~"Void"; } - 1 { ret "Float"; } - 2 { ret "Double"; } - 3 { ret "X86_FP80"; } - 4 { ret "FP128"; } - 5 { ret "PPC_FP128"; } - 6 { ret "Label"; } + 1 { ret ~"Float"; } + 2 { ret ~"Double"; } + 3 { ret ~"X86_FP80"; } + 4 { ret ~"FP128"; } + 5 { ret ~"PPC_FP128"; } + 6 { ret ~"Label"; } 7 { - ret "i" + istr::to_estr(std::int::str( - llvm::LLVMGetIntTypeWidth(ty) as int)); + ret ~"i" + std::int::str( + llvm::LLVMGetIntTypeWidth(ty) as int); } 8 { - let s = "fn("; + let s = ~"fn("; let out_ty: TypeRef = llvm::LLVMGetReturnType(ty); let n_args: uint = llvm::LLVMCountParamTypes(ty); let args: [TypeRef] = vec::init_elt::(0 as TypeRef, n_args); llvm::LLVMGetParamTypes(ty, vec::to_ptr(args)); s += tys_str(names, outer, args); - s += ") -> "; + s += ~") -> "; s += type_to_str_inner(names, outer, out_ty); ret s; } @@ -1001,12 +1002,12 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) -> 9 { - let s: str = "{"; + let s: istr = ~"{"; let n_elts: uint = llvm::LLVMCountStructElementTypes(ty); let elts: [TypeRef] = vec::init_elt::(0 as TypeRef, n_elts); llvm::LLVMGetStructElementTypes(ty, vec::to_ptr(elts)); s += tys_str(names, outer, elts); - s += "}"; + s += ~"}"; ret s; } @@ -1014,7 +1015,7 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) -> 10 { let el_ty = llvm::LLVMGetElementType(ty); - ret "[" + type_to_str_inner(names, outer, el_ty) + "]"; + ret ~"[" + type_to_str_inner(names, outer, el_ty) + ~"]"; } @@ -1025,20 +1026,20 @@ fn type_to_str_inner(names: type_names, outer0: &[TypeRef], ty: TypeRef) -> i += 1u; if tout as int == ty as int { let n: uint = vec::len::(outer0) - i; - ret "*\\" + istr::to_estr(std::int::str(n as int)); + ret ~"*\\" + std::int::str(n as int); } } - ret "*" + + ret ~"*" + type_to_str_inner(names, outer, llvm::LLVMGetElementType(ty)); } 12 { - ret "Opaque"; + ret ~"Opaque"; } - 13 { ret "Vector"; } - 14 { ret "Metadata"; } + 13 { ret ~"Vector"; } + 14 { ret ~"Metadata"; } _ { log_err #fmt["unknown TypeKind %d", kind as int]; fail; } } } @@ -1068,8 +1069,8 @@ resource target_data_res(TD: TargetDataRef) { type target_data = {lltd: TargetDataRef, dtor: @target_data_res}; -fn mk_target_data(string_rep: str) -> target_data { - let lltd = istr::as_buf(istr::from_estr(string_rep), { |buf| +fn mk_target_data(string_rep: &istr) -> target_data { + let lltd = istr::as_buf(string_rep, { |buf| llvm::LLVMCreateTargetData(buf) }); ret {lltd: lltd, dtor: @target_data_res(lltd)}; diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 351cbdc1817d..200fd042416d 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -6306,7 +6306,7 @@ fn make_common_glue(sess: &session::session, output: &str) { let _: () = istr::as_buf(x86::get_target_triple(), { |buf| llvm::LLVMSetTarget(llmod, buf) }); - mk_target_data(istr::to_estr(x86::get_data_layout())); + mk_target_data(x86::get_data_layout()); declare_intrinsics(llmod); let _: () = istr::as_buf(x86::get_module_asm(), { |buf| llvm::LLVMSetModuleInlineAsm(llmod, buf) @@ -6411,14 +6411,14 @@ fn trans_crate(sess: &session::session, crate: &@ast::crate, tcx: &ty::ctxt, let _: () = istr::as_buf(x86::get_target_triple(), { |buf| llvm::LLVMSetTarget(llmod, buf) }); - let td = mk_target_data(istr::to_estr(x86::get_data_layout())); + let td = mk_target_data(x86::get_data_layout()); 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); + tn.associate(~"taskptr", taskptr_type); let tydesc_type = T_tydesc(taskptr_type); - tn.associate("tydesc", tydesc_type); + tn.associate(~"tydesc", tydesc_type); let glues = make_glues(llmod, taskptr_type); let hasher = ty::hash_ty; let eqer = ty::eq_ty; diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs index 5d43c022c813..f193f1e5623a 100644 --- a/src/comp/middle/trans_common.rs +++ b/src/comp/middle/trans_common.rs @@ -439,7 +439,7 @@ fn rslt(bcx: @block_ctxt, val: ValueRef) -> result { } fn ty_str(tn: type_names, t: TypeRef) -> str { - ret lib::llvm::type_to_str(tn, t); + ret istr::to_estr(lib::llvm::type_to_str(tn, t)); } fn val_ty(v: ValueRef) -> TypeRef { ret llvm::LLVMTypeOf(v); } @@ -609,7 +609,7 @@ fn T_tydesc_field(cx: &crate_ctxt, field: int) -> TypeRef { } fn T_glue_fn(cx: &crate_ctxt) -> TypeRef { - let s = "glue_fn"; + let s = ~"glue_fn"; if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); } let t = T_tydesc_field(cx, abi::tydesc_field_drop_glue); cx.tn.associate(s, t); @@ -617,7 +617,7 @@ fn T_glue_fn(cx: &crate_ctxt) -> TypeRef { } fn T_cmp_glue_fn(cx: &crate_ctxt) -> TypeRef { - let s = "cmp_glue_fn"; + let s = ~"cmp_glue_fn"; if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); } let t = T_tydesc_field(cx, abi::tydesc_field_cmp_glue); cx.tn.associate(s, t); @@ -625,7 +625,7 @@ fn T_cmp_glue_fn(cx: &crate_ctxt) -> TypeRef { } fn T_copy_glue_fn(cx: &crate_ctxt) -> TypeRef { - let s = "copy_glue_fn"; + let s = ~"copy_glue_fn"; if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); } let t = T_tydesc_field(cx, abi::tydesc_field_copy_glue); cx.tn.associate(s, t); @@ -736,7 +736,7 @@ fn T_taskptr(cx: &crate_ctxt) -> TypeRef { ret T_ptr(cx.task_type); } // This type must never be used directly; it must always be cast away. fn T_typaram(tn: &type_names) -> TypeRef { - let s = "typaram"; + let s = ~"typaram"; if tn.name_has_type(s) { ret tn.get_type(s); } let t = T_i8(); tn.associate(s, t); @@ -755,7 +755,7 @@ fn T_closure_ptr(cx: &crate_ctxt, llbindings_ty: TypeRef, n_ty_params: uint) } fn T_opaque_closure_ptr(cx: &crate_ctxt) -> TypeRef { - let s = "*closure"; + let s = ~"*closure"; if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); } let t = T_closure_ptr(cx, T_nil(), 0u); cx.tn.associate(s, t); @@ -763,7 +763,7 @@ fn T_opaque_closure_ptr(cx: &crate_ctxt) -> TypeRef { } fn T_tag(tn: &type_names, size: uint) -> TypeRef { - let s = "tag_" + istr::to_estr(uint::to_str(size, 10u)); + let s = ~"tag_" + uint::to_str(size, 10u); if tn.name_has_type(s) { ret tn.get_type(s); } let t = T_struct([T_int(), T_array(T_i8(), size)]); tn.associate(s, t); @@ -771,7 +771,7 @@ fn T_tag(tn: &type_names, size: uint) -> TypeRef { } fn T_opaque_tag(tn: &type_names) -> TypeRef { - let s = "opaque_tag"; + let s = ~"opaque_tag"; if tn.name_has_type(s) { ret tn.get_type(s); } let t = T_struct([T_int(), T_i8()]); tn.associate(s, t);