Convert rustc::lib::llvm to istr::sbufs. Issue #855

src/comp/back/link.rs

@@ -34,23 +34,23 @@ tag output_type {
 
 fn llvm_err(sess: session::session, msg: &istr) {
     let buf = llvm::LLVMRustGetLastError();
-    if buf as uint == 0u {
+    if buf == std::ptr::null() {
         sess.fatal(istr::to_estr(msg));
     } else {
         sess.fatal(
-            istr::to_estr(msg) + ": " + str::str_from_cstr(buf));
+            istr::to_estr(msg + ~": " + istr::str_from_cstr(buf)));
     }
 }
 
 fn link_intrinsics(sess: session::session, llmod: ModuleRef) {
-    let path = istr::to_estr(
+    let path =
         fs::connect(istr::from_estr(sess.get_opts().sysroot),
-                    ~"lib/intrinsics.bc"));
+                    ~"lib/intrinsics.bc");
-    let membuf =
+    let membuf = istr::as_buf(path, { |buf|
-        llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(str::buf(path));
+        llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
+    });
     if membuf as uint == 0u {
-        llvm_err(sess, ~"installation problem: couldn't open "
+        llvm_err(sess, ~"installation problem: couldn't open " + path);
-                 + istr::from_estr(path));
         fail;
     }
     let llintrinsicsmod = llvm::LLVMRustParseBitcode(membuf);
@@ -104,14 +104,16 @@ mod write {
               output_type_bitcode. {
                 if opts.optimize != 0u {
                     let filename = mk_intermediate_name(output, ~"no-opt.bc");
-                    let filename = istr::to_estr(filename);
+                    istr::as_buf(filename, { |buf|
-                    llvm::LLVMWriteBitcodeToFile(llmod, str::buf(filename));
+                        llvm::LLVMWriteBitcodeToFile(llmod, buf)
+                    });
                 }
               }
               _ {
                 let filename = mk_intermediate_name(output, ~"bc");
-                let filename = istr::to_estr(filename);
+                istr::as_buf(filename, { |buf|
-                llvm::LLVMWriteBitcodeToFile(llmod, str::buf(filename));
+                    llvm::LLVMWriteBitcodeToFile(llmod, buf)
+                });
               }
             }
         }
@@ -183,20 +185,24 @@ mod write {
                 // Always output the bitcode file with --save-temps
 
                 let filename = mk_intermediate_name(output, ~"opt.bc");
-                let filename = istr::to_estr(filename);
                 llvm::LLVMRunPassManager(pm.llpm, llmod);
-                llvm::LLVMWriteBitcodeToFile(llmod, str::buf(filename));
+                istr::as_buf(filename, { |buf|
+                    llvm::LLVMWriteBitcodeToFile(llmod, buf)
+                });
                 pm = mk_pass_manager();
                 // Save the assembly file if -S is used
 
                 if opts.output_type == output_type_assembly {
-                    let triple = istr::to_estr(x86::get_target_triple());
+                    let _: () =
-                    let output = istr::to_estr(output);
+                        istr::as_buf(x86::get_target_triple(), { |buf_t|
-                    llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
+                            istr::as_buf(output, { |buf_o|
-                                                  str::buf(triple),
+                                llvm::LLVMRustWriteOutputFile(
-                                                  str::buf(output),
+                                    pm.llpm, llmod,
-                                                  LLVMAssemblyFile,
+                                    buf_t,
-                                                  CodeGenOptLevel);
+                                    buf_o,
+                                    LLVMAssemblyFile,
+                                    CodeGenOptLevel)
+                                                 })});
                 }
 
 
@@ -204,24 +210,29 @@ mod write {
                 // This .o is needed when an exe is built
                 if opts.output_type == output_type_object ||
                        opts.output_type == output_type_exe {
-                    let triple = istr::to_estr(x86::get_target_triple());
+                    let _: () =
-                    let output = istr::to_estr(output);
+                        istr::as_buf(x86::get_target_triple(), { |buf_t|
-                    llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
+                            istr::as_buf(output, { |buf_o|
-                                                  str::buf(triple),
+                                llvm::LLVMRustWriteOutputFile(
-                                                  str::buf(output),
+                                    pm.llpm, llmod,
-                                                  LLVMObjectFile,
+                                    buf_t,
-                                                  CodeGenOptLevel);
+                                    buf_o,
+                                    LLVMObjectFile,
+                                    CodeGenOptLevel)
+                                                 })});
                 }
             } else {
                 // If we aren't saving temps then just output the file
                 // type corresponding to the '-c' or '-S' flag used
 
-                let triple = istr::to_estr(x86::get_target_triple());
+                let _: () = istr::as_buf(x86::get_target_triple(), { |buf_t|
-                let output = istr::to_estr(output);
+                    istr::as_buf(output, { |buf_o|
-                llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
+                        llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
-                                              str::buf(triple),
+                                                      buf_t,
-                                              str::buf(output), FileType,
+                                                      buf_o,
-                                              CodeGenOptLevel);
+                                                      FileType,
+                                                      CodeGenOptLevel)
+                                         })});
             }
             // Clean up and return
 
@@ -233,8 +244,9 @@ mod write {
         // flag, then output it here
 
         llvm::LLVMRunPassManager(pm.llpm, llmod);
-        let output = istr::to_estr(output);
+        istr::as_buf(output, { |buf|
-        llvm::LLVMWriteBitcodeToFile(llmod, str::buf(output));
+            llvm::LLVMWriteBitcodeToFile(llmod, buf)
+        });
         llvm::LLVMDisposeModule(llmod);
         if opts.time_llvm_passes { llvm::LLVMRustPrintPassTimings(); }
     }

src/comp/driver/rustc.rs

@@ -325,8 +325,8 @@ fn get_default_sysroot(binary: str) -> str {
 }
 
 fn build_target_config() -> @session::config {
-    let triple: str =
+    let triple: str = istr::to_estr(
-        std::str::rustrt::str_from_cstr(llvm::llvm::LLVMRustGetHostTriple());
+        istr::str_from_cstr(llvm::llvm::LLVMRustGetHostTriple()));
     let target_cfg: @session::config =
         @{os: get_os(triple),
           arch: get_arch(triple),

src/comp/lib/llvm.rs

@@ -1,7 +1,6 @@
 import std::vec;
-import std::str;
 import std::istr;
-import std::str::rustrt::sbuf;
+import std::istr::sbuf;
 
 import llvm::ModuleRef;
 import llvm::ContextRef;
@@ -1070,7 +1069,9 @@ 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 = llvm::LLVMCreateTargetData(str::buf(string_rep));
+    let lltd = istr::as_buf(istr::from_estr(string_rep), { |buf|
+        llvm::LLVMCreateTargetData(buf)
+    });
     ret {lltd: lltd, dtor: @target_data_res(lltd)};
 }
 

src/comp/metadata/creader.rs

@@ -192,15 +192,16 @@ fn find_library_crate_aux(nn: &{prefix: str, suffix: str}, crate_name: str,
 }
 
 fn get_metadata_section(filename: str) -> option::t<@[u8]> {
-    let b = str::buf(filename);
+    let mb = istr::as_buf(istr::from_estr(filename), { |buf|
-    let mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(b);
+        llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
+    });
     if mb as int == 0 { ret option::none::<@[u8]>; }
     let of = mk_object_file(mb);
     let si = mk_section_iter(of.llof);
     while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
         let name_buf = llvm::LLVMGetSectionName(si.llsi);
-        let name = str::str_from_cstr(name_buf);
+        let name = istr::str_from_cstr(name_buf);
-        if str::eq(name, istr::to_estr(x86::get_meta_sect_name())) {
+        if istr::eq(name, x86::get_meta_sect_name()) {
             let cbuf = llvm::LLVMGetSectionContents(si.llsi);
             let csz = llvm::LLVMGetSectionSize(si.llsi);
             let cvbuf: *u8 = std::unsafe::reinterpret_cast(cbuf);

src/comp/middle/gc.rs

@@ -11,6 +11,7 @@ import std::option::none;
 import std::option::some;
 import std::ptr;
 import std::str;
+import std::istr;
 import std::unsafe;
 import std::vec;
 
@@ -22,8 +23,9 @@ type ctxt = @{mutable next_tydesc_num: uint};
 fn mk_ctxt() -> ctxt { ret @{mutable next_tydesc_num: 0u}; }
 
 fn add_global(ccx: &@crate_ctxt, llval: ValueRef, name: str) -> ValueRef {
-    let llglobal =
+    let llglobal = istr::as_buf(istr::from_estr(name), { |buf|
-        lll::LLVMAddGlobal(ccx.llmod, val_ty(llval), str::buf(name));
+        lll::LLVMAddGlobal(ccx.llmod, val_ty(llval), buf)
+    });
     lll::LLVMSetInitializer(llglobal, llval);
     lll::LLVMSetGlobalConstant(llglobal, True);
     ret llglobal;

src/comp/middle/shape.rs

@@ -31,6 +31,7 @@ import std::map::hashmap;
 import std::option::none;
 import std::option::some;
 import std::str;
+import std::istr;
 
 import ty_ctxt = middle::ty::ctxt;
 
@@ -86,9 +87,9 @@ fn eq_res_info(a: &res_info, b: &res_info) -> bool {
 
 fn mk_global(ccx: &@crate_ctxt, name: &str, llval: ValueRef,
              internal: bool) -> ValueRef {
-    let llglobal =
+    let llglobal = istr::as_buf(istr::from_estr(name), { |buf|
-        lib::llvm::llvm::LLVMAddGlobal(ccx.llmod, val_ty(llval),
+        lib::llvm::llvm::LLVMAddGlobal(ccx.llmod, val_ty(llval), buf)
-                                       str::buf(name));
+    });
     lib::llvm::llvm::LLVMSetInitializer(llglobal, llval);
     lib::llvm::llvm::LLVMSetGlobalConstant(llglobal, True);
 
@@ -248,9 +249,9 @@ fn s_float(_tcx: &ty_ctxt) -> u8 {
 
 fn mk_ctxt(llmod: ModuleRef) -> ctxt {
     let llshapetablesty = trans_common::T_named_struct("shapes");
-    let llshapetables =
+    let llshapetables = istr::as_buf(~"shapes", { |buf|
-        lib::llvm::llvm::LLVMAddGlobal(llmod, llshapetablesty,
+        lib::llvm::llvm::LLVMAddGlobal(llmod, llshapetablesty, buf)
-                                       str::buf("shapes"));
+    });
 
     ret {mutable next_tag_id: 0u16,
          pad: 0u16,

src/comp/middle/trans.rs

@@ -324,7 +324,9 @@ fn log_fn_time(ccx: &@crate_ctxt, name: str, start: &time::timeval,
 
 fn decl_fn(llmod: ModuleRef, name: &str, cc: uint, llty: TypeRef) ->
    ValueRef {
-    let llfn: ValueRef = llvm::LLVMAddFunction(llmod, str::buf(name), llty);
+    let llfn: ValueRef = istr::as_buf(istr::from_estr(name), { |buf|
+        llvm::LLVMAddFunction(llmod, buf, llty)
+    });
     llvm::LLVMSetFunctionCallConv(llfn, cc);
     ret llfn;
 }
@@ -335,7 +337,9 @@ fn decl_cdecl_fn(llmod: ModuleRef, name: &str, llty: TypeRef) -> ValueRef {
 
 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"));
+    let _: () = istr::as_buf(~"rust", { |buf|
+        llvm::LLVMSetGC(llfn, buf)
+    });
     ret llfn;
 }
 
@@ -347,7 +351,9 @@ fn decl_internal_fastcall_fn(llmod: ModuleRef, name: &str, llty: TypeRef) ->
     let llfn = decl_fn(llmod, name, lib::llvm::LLVMFastCallConv, llty);
     llvm::LLVMSetLinkage(llfn,
                          lib::llvm::LLVMInternalLinkage as llvm::Linkage);
-    llvm::LLVMSetGC(llfn, str::buf("rust"));
+    let _: () = istr::as_buf(~"rust", { |buf|
+        llvm::LLVMSetGC(llfn, buf)
+    });
     ret llfn;
 }
 
@@ -370,7 +376,9 @@ fn get_extern_const(externs: &hashmap<istr, ValueRef>, llmod: ModuleRef,
     if externs.contains_key(istr::from_estr(name)) {
         ret externs.get(istr::from_estr(name));
     }
-    let c = llvm::LLVMAddGlobal(llmod, ty, str::buf(name));
+    let c = istr::as_buf(istr::from_estr(name), { |buf|
+        llvm::LLVMAddGlobal(llmod, ty, buf)
+    });
     externs.insert(istr::from_estr(name), c);
     ret c;
 }
@@ -1140,9 +1148,9 @@ fn declare_tydesc(cx: &@local_ctxt, sp: &span, t: ty::t, ty_params: &[uint])
         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 name = istr::to_estr(name);
+    let gvar = istr::as_buf(name, { |buf|
-    let gvar =
+        llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type, buf)
-        llvm::LLVMAddGlobal(ccx.llmod, ccx.tydesc_type, str::buf(name));
+    });
     let info =
         @{ty: t,
           tydesc: gvar,
@@ -1575,7 +1583,9 @@ fn decr_refcnt_maybe_free(cx: &@block_ctxt, box_ptr_alias: ValueRef,
 // 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));
+        let _: () = istr::as_buf(istr::from_estr(s), { |buf|
+            llvm::LLVMSetValueName(v, buf)
+        });
     }
 }
 
@@ -3316,7 +3326,9 @@ fn lookup_discriminant(lcx: &@local_ctxt, vid: &ast::def_id) -> ValueRef {
         // 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));
+        let gvar = istr::as_buf(istr::from_estr(sym), { |buf|
+            llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), buf)
+        });
         llvm::LLVMSetLinkage(gvar,
                              lib::llvm::LLVMExternalLinkage as llvm::Linkage);
         llvm::LLVMSetGlobalConstant(gvar, True);
@@ -4547,8 +4559,9 @@ fn trans_log(lvl: int, cx: &@block_ctxt, e: &@ast::expr) -> result {
                 lcx.ccx,
                 istr::from_estrs(lcx.module_path),
                 ~"loglevel");
-        let s = istr::to_estr(s);
+        global = istr::as_buf(s, { |buf|
-        global = llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), str::buf(s));
+            llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(), buf)
+        });
         llvm::LLVMSetGlobalConstant(global, False);
         llvm::LLVMSetInitializer(global, C_null(T_int()));
         llvm::LLVMSetLinkage(global,
@@ -4911,14 +4924,14 @@ fn trans_stmt(cx: &@block_ctxt, s: &ast::stmt) -> result {
 // next three functions instead.
 fn new_block_ctxt(cx: &@fn_ctxt, parent: &block_parent, kind: block_kind,
                   name: &str) -> @block_ctxt {
-    let s = str::buf("");
+    let s = "";
-    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 = cx.lcx.ccx.names.next(name);
-        s = str::buf(held_name);
     }
-    let llbb: BasicBlockRef = llvm::LLVMAppendBasicBlock(cx.llfn, s);
+    let llbb: BasicBlockRef = istr::as_buf(istr::from_estr(s), { |buf|
+        llvm::LLVMAppendBasicBlock(cx.llfn, buf)
+    });
     ret @{llbb: llbb,
           mutable terminated: false,
           parent: parent,
@@ -5073,8 +5086,9 @@ fn alloc_local(cx: &@block_ctxt, local: &@ast::local) -> result {
     alt local.node.pat.node {
       ast::pat_bind(ident) {
         if bcx_ccx(cx).sess.get_opts().debuginfo {
-            let ident = istr::to_estr(ident);
+            let _: () = istr::as_buf(ident, { |buf|
-            llvm::LLVMSetValueName(r.val, str::buf(ident));
+                llvm::LLVMSetValueName(r.val, buf)
+            });
         }
       }
       _ { }
@@ -5158,11 +5172,21 @@ fn mk_standard_basic_blocks(llfn: ValueRef) ->
     dt: BasicBlockRef,
     da: BasicBlockRef,
     rt: BasicBlockRef} {
-    ret {sa: llvm::LLVMAppendBasicBlock(llfn, str::buf("static_allocas")),
+    ret {sa: istr::as_buf(~"statuc_allocas", { |buf|
-         ca: llvm::LLVMAppendBasicBlock(llfn, str::buf("copy_args")),
+             llvm::LLVMAppendBasicBlock(llfn, buf)
-         dt: llvm::LLVMAppendBasicBlock(llfn, str::buf("derived_tydescs")),
+                                             }),
-         da: llvm::LLVMAppendBasicBlock(llfn, str::buf("dynamic_allocas")),
+         ca: istr::as_buf(~"copy_args", { |buf|
-         rt: llvm::LLVMAppendBasicBlock(llfn, str::buf("return"))};
+             llvm::LLVMAppendBasicBlock(llfn, buf)
+                                        }),
+         dt: istr::as_buf(~"derived_tydescs", { |buf|
+             llvm::LLVMAppendBasicBlock(llfn, buf)
+                                              }),
+         da: istr::as_buf(~"dynamic_allocas", { |buf|
+             llvm::LLVMAppendBasicBlock(llfn, buf)
+                                              }),
+         rt: istr::as_buf(~"return", { |buf|
+             llvm::LLVMAppendBasicBlock(llfn, buf)
+                                     })};
 }
 
 
@@ -5796,8 +5820,9 @@ fn create_main_wrapper(ccx: &@crate_ctxt, sp: &span, main_llfn: ValueRef,
 // space for the function's environment.
 fn create_fn_pair(cx: &@crate_ctxt, ps: str, llfnty: TypeRef, llfn: ValueRef,
                   external: bool) -> ValueRef {
-    let gvar =
+    let gvar = istr::as_buf(istr::from_estr(ps), { |buf|
-        llvm::LLVMAddGlobal(cx.llmod, T_fn_pair(*cx, llfnty), str::buf(ps));
+        llvm::LLVMAddGlobal(cx.llmod, T_fn_pair(*cx, llfnty), buf)
+    });
     let pair = C_struct([llfn, C_null(T_opaque_closure_ptr(*cx))]);
     llvm::LLVMSetInitializer(gvar, pair);
     llvm::LLVMSetGlobalConstant(gvar, True);
@@ -6072,11 +6097,10 @@ fn collect_item_1(ccx: @crate_ctxt, i: &@ast::item, pt: &[str],
         let s =
             mangle_exported_name(ccx, istr::from_estrs(pt) + [i.ident],
                                  node_id_type(ccx, i.id));
-        let s = istr::to_estr(s);
+        let g = istr::as_buf(s, { |buf|
-        let g =
+            llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, i.span, typ), buf)
-            llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, i.span, typ),
+        });
-                                str::buf(s));
+        ccx.item_symbols.insert(i.id, istr::to_estr(s));
-        ccx.item_symbols.insert(i.id, s);
         ccx.consts.insert(i.id, g);
       }
       _ { }
@@ -6165,15 +6189,15 @@ fn trans_constant(ccx: @crate_ctxt, it: &@ast::item, pt: &[str],
                                                 ~"discrim"];
             let s = mangle_exported_name(ccx, p,
                                          ty::mk_int(ccx.tcx));
-            let s = istr::to_estr(s);
+            let discrim_gvar = istr::as_buf(s, { |buf|
-            let discrim_gvar =
+                llvm::LLVMAddGlobal(ccx.llmod, T_int(), buf)
-                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);
+            ccx.discrim_symbols.insert(variant.node.id, istr::to_estr(s));
             i += 1u;
         }
       }
@@ -6272,20 +6296,21 @@ fn make_common_glue(sess: &session::session, output: &str) {
     let task_type = T_task();
     let taskptr_type = T_ptr(task_type);
 
-    let llmod =
+    let llmod = istr::as_buf(~"rust_out", { |buf|
-        llvm::LLVMModuleCreateWithNameInContext(str::buf("rust_out"),
+        llvm::LLVMModuleCreateWithNameInContext(buf,
-                                                llvm::LLVMGetGlobalContext());
+                                                llvm::LLVMGetGlobalContext())
-    let dat_layt = istr::to_estr(
+    });
-        x86::get_data_layout()); //HACK (buf lifetime issue)
+    let _: () = istr::as_buf(x86::get_data_layout(), { |buf|
-    llvm::LLVMSetDataLayout(llmod, str::buf(dat_layt));
+        llvm::LLVMSetDataLayout(llmod, buf)
-    let targ_trip = istr::to_estr(
+    });
-        x86::get_target_triple()); //HACK (buf lifetime issue)
+    let _: () = istr::as_buf(x86::get_target_triple(), { |buf|
-    llvm::LLVMSetTarget(llmod, str::buf(targ_trip));
+        llvm::LLVMSetTarget(llmod, buf)
+    });
     mk_target_data(istr::to_estr(x86::get_data_layout()));
     declare_intrinsics(llmod);
-    let modl_asm = istr::to_estr(
+    let _: () = istr::as_buf(x86::get_module_asm(), { |buf|
-        x86::get_module_asm()); //HACK (buf lifetime issue)
+        llvm::LLVMSetModuleInlineAsm(llmod, buf)
-    llvm::LLVMSetModuleInlineAsm(llmod, str::buf(modl_asm));
+    });
     make_glues(llmod, taskptr_type);
     link::write::run_passes(sess, llmod, istr::from_estr(output));
 }
@@ -6293,8 +6318,9 @@ fn make_common_glue(sess: &session::session, output: &str) {
 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 =
+    let map = istr::as_buf(~"_rust_mod_map", { |buf|
-        llvm::LLVMAddGlobal(ccx.llmod, maptype, str::buf("_rust_mod_map"));
+        llvm::LLVMAddGlobal(ccx.llmod, maptype, buf)
+    });
     llvm::LLVMSetLinkage(map,
                          lib::llvm::LLVMInternalLinkage as llvm::Linkage);
     let elts: [ValueRef] = [];
@@ -6317,7 +6343,9 @@ fn create_crate_map(ccx: &@crate_ctxt) -> ValueRef {
     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));
+        let cr = istr::as_buf(istr::from_estr(nm), { |buf|
+            llvm::LLVMAddGlobal(ccx.llmod, T_int(), buf)
+        });
         subcrates += [p2i(cr)];
         i += 1;
     }
@@ -6326,10 +6354,12 @@ fn create_crate_map(ccx: &@crate_ctxt) -> ValueRef {
     if ccx.sess.get_opts().library {
         mapname = ccx.link_meta.name;
     } else { mapname = ~"toplevel"; }
-    let sym_name = istr::to_estr(~"_rust_crate_map_" + mapname);
+    let sym_name = ~"_rust_crate_map_" + mapname;
     let arrtype = T_array(T_int(), std::vec::len::<ValueRef>(subcrates));
     let maptype = T_struct([T_int(), arrtype]);
-    let map = llvm::LLVMAddGlobal(ccx.llmod, maptype, str::buf(sym_name));
+    let map = istr::as_buf(sym_name, { |buf|
+        llvm::LLVMAddGlobal(ccx.llmod, maptype, buf)
+    });
     llvm::LLVMSetLinkage(map,
                          lib::llvm::LLVMExternalLinkage as llvm::Linkage);
     llvm::LLVMSetInitializer(map,
@@ -6342,21 +6372,21 @@ 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 =
+    let llglobal = istr::as_buf(~"rust_metadata", { |buf|
-        llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst),
+        llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst), buf)
-                            str::buf("rust_metadata"));
+    });
     llvm::LLVMSetInitializer(llglobal, llconst);
-    let met_sct_nm = istr::to_estr(
+    let _: () = istr::as_buf(x86::get_meta_sect_name(), { |buf|
-        x86::get_meta_sect_name()); //HACK (buf lifetime issue)
+        llvm::LLVMSetSection(llglobal, buf)
-    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 =
+    let llvm_used = istr::as_buf(~"llvm.used", { |buf|
-        llvm::LLVMAddGlobal(cx.llmod, T_array(t_ptr_i8, 1u),
+        llvm::LLVMAddGlobal(cx.llmod, T_array(t_ptr_i8, 1u), buf)
-                            str::buf("llvm.used"));
+    });
     llvm::LLVMSetLinkage(llvm_used,
                          lib::llvm::LLVMAppendingLinkage as llvm::Linkage);
     llvm::LLVMSetInitializer(llvm_used, C_array(t_ptr_i8, [llglobal]));
@@ -6371,16 +6401,17 @@ fn write_abi_version(ccx: &@crate_ctxt) {
 fn trans_crate(sess: &session::session, crate: &@ast::crate, tcx: &ty::ctxt,
                output: &str, amap: &ast_map::map, mut_map: alias::mut_map)
     -> ModuleRef {
-    let llmod =
+    let llmod = istr::as_buf(~"rust_out", { |buf|
-        llvm::LLVMModuleCreateWithNameInContext(str::buf("rust_out"),
+        llvm::LLVMModuleCreateWithNameInContext(buf,
-                                                llvm::LLVMGetGlobalContext());
+                                                llvm::LLVMGetGlobalContext())
-    let dat_layt = istr::to_estr(
+    });
-        x86::get_data_layout()); //HACK (buf lifetime issue)
+    let _: () = istr::as_buf(x86::get_data_layout(), { |buf|
-    llvm::LLVMSetDataLayout(llmod, str::buf(dat_layt));
+        llvm::LLVMSetDataLayout(llmod, buf)
-    let targ_trip = istr::to_estr(
+    });
-        x86::get_target_triple()); //HACK (buf lifetime issue)
+    let _: () = istr::as_buf(x86::get_target_triple(), { |buf|
-    llvm::LLVMSetTarget(llmod, str::buf(targ_trip));
+        llvm::LLVMSetTarget(llmod, buf)
-    let td = mk_target_data(dat_layt);
+    });
+    let td = mk_target_data(istr::to_estr(x86::get_data_layout()));
     let tn = mk_type_names();
     let intrinsics = declare_intrinsics(llmod);
     let task_type = T_task();

src/comp/middle/trans_build.rs

@@ -1,5 +1,5 @@
-import std::{vec, str};
+import std::{vec, str, istr};
-import str::rustrt::sbuf;
+import std::istr::sbuf;
 import lib::llvm::llvm;
 import llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef,
               Opcode, ModuleRef};
@@ -71,8 +71,10 @@ fn Invoke(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef],
     cx.terminated = true;
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildInvoke(B, Fn, vec::to_ptr(Args),
+    ret istr::as_buf(~"", { |buf|
-                              vec::len(Args), Then, Catch, str::buf(""));
+        llvm::LLVMBuildInvoke(B, Fn, vec::to_ptr(Args),
+                              vec::len(Args), Then, Catch, buf)
+    });
 }
 
 fn Unreachable(cx: &@block_ctxt) -> ValueRef {
@@ -87,211 +89,282 @@ fn Unreachable(cx: &@block_ctxt) -> ValueRef {
 fn Add(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildAdd(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildAdd(B, LHS, RHS, buf)
+    });
 }
 
 fn NSWAdd(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNSWAdd(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNSWAdd(B, LHS, RHS, buf)
+    });
 }
 
 fn NUWAdd(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNUWAdd(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNUWAdd(B, LHS, RHS, buf)
+    });
 }
 
 fn FAdd(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFAdd(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFAdd(B, LHS, RHS, buf)
+    });
 }
 
 fn Sub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildSub(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildSub(B, LHS, RHS, buf)
+    });
 }
 
 fn NSWSub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNSWSub(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNSWSub(B, LHS, RHS, buf)
+    });
 }
 
 fn NUWSub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNUWSub(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNUWSub(B, LHS, RHS, buf)
+    });
 }
 
 fn FSub(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFSub(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFSub(B, LHS, RHS, buf)
+    });
 }
 
 fn Mul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildMul(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildMul(B, LHS, RHS, buf)
+    });
 }
 
 fn NSWMul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNSWMul(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNSWMul(B, LHS, RHS, buf)
+    });
 }
 
 fn NUWMul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNUWMul(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNUWMul(B, LHS, RHS, buf)
+    });
 }
 
 fn FMul(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFMul(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFMul(B, LHS, RHS, buf)
+    });
 }
 
 fn UDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildUDiv(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildUDiv(B, LHS, RHS, buf)
+    });
 }
 
 fn SDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildSDiv(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildSDiv(B, LHS, RHS, buf)
+    });
 }
 
 fn ExactSDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildExactSDiv(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildExactSDiv(B, LHS, RHS, buf)
+    });
 }
 
 fn FDiv(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFDiv(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFDiv(B, LHS, RHS, buf)
+    });
 }
 
 fn URem(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildURem(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildURem(B, LHS, RHS, buf)
+    });
 }
 
 fn SRem(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildSRem(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildSRem(B, LHS, RHS, buf)
+    });
 }
 
 fn FRem(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFRem(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFRem(B, LHS, RHS, buf)
+    });
 }
 
 fn Shl(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildShl(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildShl(B, LHS, RHS, buf)
+    });
 }
 
 fn LShr(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildLShr(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildLShr(B, LHS, RHS, buf)
+    });
 }
 
 fn AShr(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildAShr(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildAShr(B, LHS, RHS, buf)
+    });
 }
 
 fn And(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildAnd(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildAnd(B, LHS, RHS, buf)
+    });
 }
 
 fn Or(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildOr(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildOr(B, LHS, RHS, buf)
+    });
 }
 
 fn Xor(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildXor(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildXor(B, LHS, RHS, buf)
+    });
 }
 
 fn BinOp(cx: &@block_ctxt, Op: Opcode, LHS: ValueRef,
          RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildBinOp(B, Op, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildBinOp(B, Op, LHS, RHS, buf)
+    });
 }
 
 fn Neg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNeg(B, V, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNeg(B, V, buf)
+    });
 }
 
 fn NSWNeg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNSWNeg(B, V, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNSWNeg(B, V, buf)
+    });
 }
 
 fn NUWNeg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNUWNeg(B, V, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNUWNeg(B, V, buf)
+    });
 }
 fn FNeg(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFNeg(B, V, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFNeg(B, V, buf)
+    });
 }
+
 fn Not(cx: &@block_ctxt, V: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildNot(B, V, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildNot(B, V, buf)
+    });
 }
 
 /* Memory */
 fn Malloc(cx: &@block_ctxt, Ty: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildMalloc(B, Ty, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildMalloc(B, Ty, buf)
+    });
 }
 
 fn ArrayMalloc(cx: &@block_ctxt, Ty: TypeRef, Val: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildArrayMalloc(B, Ty, Val, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildArrayMalloc(B, Ty, Val, buf)
+    });
 }
 
 fn Alloca(cx: &@block_ctxt, Ty: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildAlloca(B, Ty, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildAlloca(B, Ty, buf)
+    });
 }
 
 fn ArrayAlloca(cx: &@block_ctxt, Ty: TypeRef, Val: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildArrayAlloca(B, Ty, Val, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildArrayAlloca(B, Ty, Val, buf)
+    });
 }
 
 fn Free(cx: &@block_ctxt, PointerVal: ValueRef) -> ValueRef {
@@ -303,7 +376,9 @@ fn Free(cx: &@block_ctxt, PointerVal: ValueRef) -> ValueRef {
 fn Load(cx: &@block_ctxt, PointerVal: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildLoad(B, PointerVal, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildLoad(B, PointerVal, buf)
+    });
 }
 
 fn Store(cx: &@block_ctxt, Val: ValueRef, Ptr: ValueRef) -> ValueRef {
@@ -316,130 +391,170 @@ fn GEP(cx: &@block_ctxt, Pointer: ValueRef,
        Indices: &[ValueRef]) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildGEP(B, Pointer, vec::to_ptr(Indices),
+    ret istr::as_buf(~"", { |buf|
-                           vec::len(Indices), str::buf(""));
+        llvm::LLVMBuildGEP(B, Pointer, vec::to_ptr(Indices),
+                           vec::len(Indices), buf)
+    });
 }
 
 fn InBoundsGEP(cx: &@block_ctxt, Pointer: ValueRef,
                Indices: &[ValueRef]) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildInBoundsGEP(B, Pointer, vec::to_ptr(Indices),
+    ret istr::as_buf(~"", { |buf|
-                                   vec::len(Indices), str::buf(""));
+        llvm::LLVMBuildInBoundsGEP(B, Pointer, vec::to_ptr(Indices),
+                                   vec::len(Indices), buf)
+    });
 }
 
 fn StructGEP(cx: &@block_ctxt, Pointer: ValueRef, Idx: uint) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildStructGEP(B, Pointer, Idx, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildStructGEP(B, Pointer, Idx, buf)
+    });
 }
 
 fn GlobalString(cx: &@block_ctxt, _Str: sbuf) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildGlobalString(B, _Str, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildGlobalString(B, _Str, buf)
+    });
 }
 
 fn GlobalStringPtr(cx: &@block_ctxt, _Str: sbuf) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildGlobalStringPtr(B, _Str, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildGlobalStringPtr(B, _Str, buf)
+    });
 }
 
 /* Casts */
 fn Trunc(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildTrunc(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildTrunc(B, Val, DestTy, buf)
+    });
 }
 
 fn ZExt(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildZExt(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildZExt(B, Val, DestTy, buf)
+    });
 }
 
 fn SExt(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildSExt(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildSExt(B, Val, DestTy, buf)
+    });
 }
 
 fn FPToUI(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFPToUI(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFPToUI(B, Val, DestTy, buf)
+    });
 }
 
 fn FPToSI(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFPToSI(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFPToSI(B, Val, DestTy, buf)
+    });
 }
 
 fn UIToFP(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildUIToFP(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildUIToFP(B, Val, DestTy, buf)
+    });
 }
 
 fn SIToFP(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildSIToFP(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildSIToFP(B, Val, DestTy, buf)
+    });
 }
 
 fn FPTrunc(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFPTrunc(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFPTrunc(B, Val, DestTy, buf)
+    });
 }
 
 fn FPExt(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFPExt(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFPExt(B, Val, DestTy, buf)
+    });
 }
 
 fn PtrToInt(cx: &@block_ctxt, Val: ValueRef,
             DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildPtrToInt(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildPtrToInt(B, Val, DestTy, buf)
+    });
 }
 
 fn IntToPtr(cx: &@block_ctxt, Val: ValueRef,
             DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildIntToPtr(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildIntToPtr(B, Val, DestTy, buf)
+    });
 }
 
 fn BitCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildBitCast(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildBitCast(B, Val, DestTy, buf)
+    });
 }
 
 fn ZExtOrBitCast(cx: &@block_ctxt, Val: ValueRef,
                  DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildZExtOrBitCast(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildZExtOrBitCast(B, Val, DestTy, buf)
+    });
 }
 
 fn SExtOrBitCast(cx: &@block_ctxt, Val: ValueRef,
                  DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildSExtOrBitCast(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildSExtOrBitCast(B, Val, DestTy, buf)
+    });
 }
 
 fn TruncOrBitCast(cx: &@block_ctxt, Val: ValueRef,
                   DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildTruncOrBitCast(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildTruncOrBitCast(B, Val, DestTy, buf)
+    });
 }
 
 fn Cast(cx: &@block_ctxt, Op: Opcode, Val: ValueRef,
@@ -447,25 +562,33 @@ fn Cast(cx: &@block_ctxt, Op: Opcode, Val: ValueRef,
     ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildCast(B, Op, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildCast(B, Op, Val, DestTy, buf)
+    });
 }
 
 fn PointerCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildPointerCast(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildPointerCast(B, Val, DestTy, buf)
+    });
 }
 
 fn IntCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildIntCast(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildIntCast(B, Val, DestTy, buf)
+    });
 }
 
 fn FPCast(cx: &@block_ctxt, Val: ValueRef, DestTy: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFPCast(B, Val, DestTy, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFPCast(B, Val, DestTy, buf)
+    });
 }
 
 
@@ -474,14 +597,18 @@ fn ICmp(cx: &@block_ctxt, Op: uint, LHS: ValueRef,
         RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildICmp(B, Op, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildICmp(B, Op, LHS, RHS, buf)
+    });
 }
 
 fn FCmp(cx: &@block_ctxt, Op: uint, LHS: ValueRef,
         RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildFCmp(B, Op, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildFCmp(B, Op, LHS, RHS, buf)
+    });
 }
 
 
@@ -490,7 +617,9 @@ fn Phi(cx: &@block_ctxt, Ty: TypeRef, vals: &[ValueRef],
        bbs: &[BasicBlockRef]) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    let phi = llvm::LLVMBuildPhi(B, Ty, str::buf(""));
+    let phi = istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildPhi(B, Ty, buf)
+    });
     assert (vec::len::<ValueRef>(vals) == vec::len::<BasicBlockRef>(bbs));
     llvm::LLVMAddIncoming(phi, vec::to_ptr(vals), vec::to_ptr(bbs),
                           vec::len(vals));
@@ -506,16 +635,18 @@ fn AddIncomingToPhi(phi: ValueRef, vals: &[ValueRef], bbs: &[BasicBlockRef]) {
 fn Call(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args),
+    ret istr::as_buf(~"", { |buf|
-                            str::buf(""));
+        llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args),
+                            vec::len(Args), buf)
+    });
 }
 
 fn FastCall(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    let v =
+    let v = istr::as_buf(~"", { |buf|
-        llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args),
+        llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args), buf)
-                            str::buf(""));
+    });
     llvm::LLVMSetInstructionCallConv(v, lib::llvm::LLVMFastCallConv);
     ret v;
 }
@@ -524,9 +655,9 @@ fn CallWithConv(cx: &@block_ctxt, Fn: ValueRef, Args: &[ValueRef],
                 Conv: uint) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    let v =
+    let v = istr::as_buf(~"", { |buf|
-        llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args),
+        llvm::LLVMBuildCall(B, Fn, vec::to_ptr(Args), vec::len(Args), buf)
-                            str::buf(""));
+    });
     llvm::LLVMSetInstructionCallConv(v, Conv);
     ret v;
 }
@@ -535,20 +666,26 @@ fn Select(cx: &@block_ctxt, If: ValueRef, Then: ValueRef,
           Else: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildSelect(B, If, Then, Else, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildSelect(B, If, Then, Else, buf)
+    });
 }
 
 fn VAArg(cx: &@block_ctxt, list: ValueRef, Ty: TypeRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildVAArg(B, list, Ty, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildVAArg(B, list, Ty, buf)
+    });
 }
 
 fn ExtractElement(cx: &@block_ctxt, VecVal: ValueRef,
                   Index: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildExtractElement(B, VecVal, Index, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildExtractElement(B, VecVal, Index, buf)
+    });
 }
 
 fn InsertElement(cx: &@block_ctxt, VecVal: ValueRef, EltVal: ValueRef,
@@ -556,47 +693,59 @@ fn InsertElement(cx: &@block_ctxt, VecVal: ValueRef, EltVal: ValueRef,
     ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildInsertElement(B, VecVal, EltVal, Index,
+    ret istr::as_buf(~"", { |buf|
-                                     str::buf(""));
+        llvm::LLVMBuildInsertElement(B, VecVal, EltVal, Index, buf)
+    });
 }
 
 fn ShuffleVector(cx: &@block_ctxt, V1: ValueRef, V2: ValueRef,
                  Mask: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildShuffleVector(B, V1, V2, Mask, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildShuffleVector(B, V1, V2, Mask, buf)
+    });
 }
 
 fn ExtractValue(cx: &@block_ctxt, AggVal: ValueRef, Index: uint) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildExtractValue(B, AggVal, Index, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildExtractValue(B, AggVal, Index, buf)
+    });
 }
 
 fn InsertValue(cx: &@block_ctxt, AggVal: ValueRef,
                EltVal: ValueRef, Index: uint) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildInsertValue(B, AggVal, EltVal, Index,
+    ret istr::as_buf(~"", { |buf|
-                                   str::buf(""));
+        llvm::LLVMBuildInsertValue(B, AggVal, EltVal, Index, buf)
+    });
 }
 
 fn IsNull(cx: &@block_ctxt, Val: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildIsNull(B, Val, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildIsNull(B, Val, buf)
+    });
 }
 
 fn IsNotNull(cx: &@block_ctxt, Val: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildIsNotNull(B, Val, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildIsNotNull(B, Val, buf)
+    });
 }
 
 fn PtrDiff(cx: &@block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
     let B = *cx.fcx.lcx.ccx.builder;
     llvm::LLVMPositionBuilderAtEnd(B, cx.llbb);
-    ret llvm::LLVMBuildPtrDiff(B, LHS, RHS, str::buf(""));
+    ret istr::as_buf(~"", { |buf|
+        llvm::LLVMBuildPtrDiff(B, LHS, RHS, buf)
+    });
 }
 
 fn Trap(cx: &@block_ctxt) -> ValueRef {
@@ -605,12 +754,14 @@ fn Trap(cx: &@block_ctxt) -> ValueRef {
     let BB: BasicBlockRef = llvm::LLVMGetInsertBlock(B);
     let FN: ValueRef = llvm::LLVMGetBasicBlockParent(BB);
     let M: ModuleRef = llvm::LLVMGetGlobalParent(FN);
-    let T: ValueRef =
+    let T: ValueRef = istr::as_buf(~"llvm.trap", { |buf|
-        llvm::LLVMGetNamedFunction(M, str::buf("llvm.trap"));
+        llvm::LLVMGetNamedFunction(M, buf)
+    });
     assert (T as int != 0);
     let Args: [ValueRef] = [];
-    ret llvm::LLVMBuildCall(B, T, vec::to_ptr(Args), vec::len(Args),
+    ret istr::as_buf(~"", { |buf|
-                            str::buf(""));
+        llvm::LLVMBuildCall(B, T, vec::to_ptr(Args), vec::len(Args), buf)
+    });
 }
 
 //

src/comp/middle/trans_common.rs

@@ -553,7 +553,9 @@ fn T_struct(elts: &[TypeRef]) -> TypeRef {
 
 fn T_named_struct(name: &str) -> TypeRef {
     let c = llvm::LLVMGetGlobalContext();
-    ret llvm::LLVMStructCreateNamed(c, str::buf(name));
+    ret istr::as_buf(istr::from_estr(name), { |buf|
+        llvm::LLVMStructCreateNamed(c, buf)
+    });
 }
 
 fn set_struct_body(t: TypeRef, elts: &[TypeRef]) {
@@ -816,11 +818,15 @@ fn C_integral(t: TypeRef, u: uint, sign_extend: Bool) -> ValueRef {
 }
 
 fn C_float(s: &str) -> ValueRef {
-    ret llvm::LLVMConstRealOfString(T_float(), str::buf(s));
+    ret istr::as_buf(istr::from_estr(s), { |buf|
+        llvm::LLVMConstRealOfString(T_float(), buf)
+    });
 }
 
 fn C_floating(s: &str, t: TypeRef) -> ValueRef {
-    ret llvm::LLVMConstRealOfString(t, str::buf(s));
+    ret istr::as_buf(istr::from_estr(s), { |buf|
+        llvm::LLVMConstRealOfString(t, buf)
+    });
 }
 
 fn C_nil() -> ValueRef {
@@ -845,11 +851,12 @@ fn C_u8(i: uint) -> ValueRef { ret C_integral(T_i8(), i, False); }
 // This is a 'c-like' raw string, which differs from
 // our boxed-and-length-annotated strings.
 fn C_cstr(cx: &@crate_ctxt, s: &str) -> ValueRef {
-    let sc = llvm::LLVMConstString(str::buf(s), str::byte_len(s), False);
+    let sc = istr::as_buf(istr::from_estr(s), { |buf|
-    let gname = cx.names.next("str");
+        llvm::LLVMConstString(buf, str::byte_len(s), False)
-    let g =
+    });
-        llvm::LLVMAddGlobal(cx.llmod, val_ty(sc),
+    let g = istr::as_buf(istr::from_estr(cx.names.next("str")), { |buf|
-                            str::buf(gname));
+        llvm::LLVMAddGlobal(cx.llmod, val_ty(sc), buf)
+    });
     llvm::LLVMSetInitializer(g, sc);
     llvm::LLVMSetGlobalConstant(g, True);
     llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage as llvm::Linkage);
@@ -864,13 +871,15 @@ fn C_str(cx: &@crate_ctxt, s: &str) -> ValueRef {
                           // 'fill'
                           // 'pad'
 
+    let cstr = istr::as_buf(istr::from_estr(s), { |buf|
+        llvm::LLVMConstString(buf, len, False)
+    });
     let box =
         C_struct([C_int(abi::const_refcount as int), C_int(len + 1u as int),
-                  C_int(len + 1u as int), C_int(0),
+                  C_int(len + 1u as int), C_int(0), cstr]);
-                  llvm::LLVMConstString(str::buf(s), len, False)]);
+    let g = istr::as_buf(istr::from_estr(cx.names.next("str")), { |buf|
-    let gname = cx.names.next("str");
+        llvm::LLVMAddGlobal(cx.llmod, val_ty(box), buf)
-    let g =
+    });
-        llvm::LLVMAddGlobal(cx.llmod, val_ty(box), str::buf(gname));
     llvm::LLVMSetInitializer(g, box);
     llvm::LLVMSetGlobalConstant(g, True);
     llvm::LLVMSetLinkage(g, lib::llvm::LLVMInternalLinkage as llvm::Linkage);
@@ -879,7 +888,9 @@ fn C_str(cx: &@crate_ctxt, s: &str) -> ValueRef {
 
 // Returns a Plain Old LLVM String:
 fn C_postr(s: &str) -> ValueRef {
-    ret llvm::LLVMConstString(str::buf(s), str::byte_len(s), False);
+    ret istr::as_buf(istr::from_estr(s), { |buf|
+        llvm::LLVMConstString(buf, str::byte_len(s), False)
+    });
 }
 
 fn C_zero_byte_arr(size: uint) -> ValueRef {
@@ -911,9 +922,10 @@ fn C_bytes(bytes: &[u8]) -> ValueRef {
 
 fn C_shape(ccx: &@crate_ctxt, bytes: &[u8]) -> ValueRef {
     let llshape = C_bytes(bytes);
-    let gname = ccx.names.next("shape");
+    let llglobal = istr::as_buf(
-    let llglobal =
+        istr::from_estr(ccx.names.next("shape")), { |buf|
-        llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), str::buf(gname));
+        llvm::LLVMAddGlobal(ccx.llmod, val_ty(llshape), buf)
+    });
     llvm::LLVMSetInitializer(llglobal, llshape);
     llvm::LLVMSetGlobalConstant(llglobal, True);
     llvm::LLVMSetLinkage(llglobal,

src/comp/middle/trans_objects.rs

@@ -571,9 +571,9 @@ fn finish_vtbl(cx: @local_ctxt, llmethods: [ValueRef], name: str) ->
     let vtbl = C_struct(llmethods);
     let vtbl_name = mangle_internal_name_by_path(
         cx.ccx, istr::from_estrs(cx.path + [name]));
-    let vtbl_name = istr::to_estr(vtbl_name);
+    let gvar = istr::as_buf(vtbl_name, { |buf|
-    let gvar =
+        llvm::LLVMAddGlobal(cx.ccx.llmod, val_ty(vtbl), buf)
-        llvm::LLVMAddGlobal(cx.ccx.llmod, val_ty(vtbl), str::buf(vtbl_name));
+    });
     llvm::LLVMSetInitializer(gvar, vtbl);
     llvm::LLVMSetGlobalConstant(gvar, True);
     llvm::LLVMSetLinkage(gvar,