rustc: Avoid an allocation on every GEPi

8 files changed, 110 insertions, 114 deletions

diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs
index 0ce0cfc8acc..5bd13aaa24a 100644
--- a/src/rustc/middle/trans/alt.rs
+++ b/src/rustc/middle/trans/alt.rs
@@ -317,7 +317,7 @@ fn extract_variant_args(bcx: block, pat_id: ast::node_id,
     if size > 0u && (*variants).len() != 1u {
         let enumptr =
             PointerCast(bcx, val, T_opaque_enum_ptr(ccx));
-        blobptr = GEPi(bcx, enumptr, ~[0u, 1u]);
+        blobptr = GEPi(bcx, enumptr, [0u, 1u]);
     }
     let vdefs_tg = vdefs.enm;
     let vdefs_var = vdefs.var;
@@ -525,7 +525,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
         let mut rec_vals = ~[];
         for vec::each(rec_fields) |field_name| {
             let ix = option::get(ty::field_idx(field_name, fields));
-            vec::push(rec_vals, GEPi(bcx, val, ~[0u, ix]));
+            vec::push(rec_vals, GEPi(bcx, val, [0u, ix]));
         }
         compile_submatch(bcx,
                          enter_rec_or_struct(bcx, dm, m, col, rec_fields,
@@ -581,7 +581,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
         };
         let mut tup_vals = ~[], i = 0u;
         while i < n_tup_elts {
-            vec::push(tup_vals, GEPi(bcx, val, ~[0u, i]));
+            vec::push(tup_vals, GEPi(bcx, val, [0u, i]));
             i += 1u;
         }
         compile_submatch(bcx, enter_tup(bcx, dm, m, col, val, n_tup_elts),
@@ -594,7 +594,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
         let llbox = Load(bcx, val);
         let box_no_addrspace = non_gc_box_cast(bcx, llbox);
         let unboxed =
-            GEPi(bcx, box_no_addrspace, ~[0u, abi::box_field_body]);
+            GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
         compile_submatch(bcx, enter_box(bcx, dm, m, col, val),
                          vec::append(~[unboxed], vals_left), chk, exits);
         return;
@@ -604,7 +604,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
         let llbox = Load(bcx, val);
         let box_no_addrspace = non_gc_box_cast(bcx, llbox);
         let unboxed =
-            GEPi(bcx, box_no_addrspace, ~[0u, abi::box_field_body]);
+            GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
         compile_submatch(bcx, enter_uniq(bcx, dm, m, col, val),
                          vec::append(~[unboxed], vals_left), chk, exits);
         return;
@@ -623,7 +623,7 @@ fn compile_submatch(bcx: block, m: match_, vals: ~[ValueRef],
             } else {
                 let enumptr =
                     PointerCast(bcx, val, T_opaque_enum_ptr(ccx));
-                let discrimptr = GEPi(bcx, enumptr, ~[0u, 0u]);
+                let discrimptr = GEPi(bcx, enumptr, [0u, 0u]);
                 test_val = Load(bcx, discrimptr);
                 kind = switch;
             }
@@ -932,7 +932,7 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
         let rec_fields = ty::get_fields(node_id_type(bcx, pat.id));
         for vec::each(fields) |f| {
             let ix = option::get(ty::field_idx(f.ident, rec_fields));
-            let fldptr = GEPi(bcx, val, ~[0u, ix]);
+            let fldptr = GEPi(bcx, val, [0u, ix]);
             bcx = bind_irrefutable_pat(bcx, f.pat, fldptr, make_copy);
         }
       }
@@ -967,7 +967,7 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
       ast::pat_tup(elems) => {
         let mut i = 0u;
         for vec::each(elems) |elem| {
-            let fldptr = GEPi(bcx, val, ~[0u, i]);
+            let fldptr = GEPi(bcx, val, [0u, i]);
             bcx = bind_irrefutable_pat(bcx, elem, fldptr, make_copy);
             i += 1u;
         }
@@ -975,13 +975,13 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
       ast::pat_box(inner) => {
         let llbox = Load(bcx, val);
         let unboxed =
-            GEPi(bcx, llbox, ~[0u, abi::box_field_body]);
+            GEPi(bcx, llbox, [0u, abi::box_field_body]);
         bcx = bind_irrefutable_pat(bcx, inner, unboxed, true);
       }
       ast::pat_uniq(inner) => {
         let llbox = Load(bcx, val);
         let unboxed =
-            GEPi(bcx, llbox, ~[0u, abi::box_field_body]);
+            GEPi(bcx, llbox, [0u, abi::box_field_body]);
         bcx = bind_irrefutable_pat(bcx, inner, unboxed, true);
       }
       ast::pat_wild | ast::pat_lit(_) | ast::pat_range(_, _) => ()
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 73a9a0cec9b..5afab464748 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -362,7 +362,7 @@ fn GEP_enum(bcx: block, llblobptr: ValueRef, enum_id: ast::def_id,
     });
     let typed_blobptr = PointerCast(bcx, llblobptr,
                                     T_ptr(T_struct(arg_lltys)));
-    GEPi(bcx, typed_blobptr, ~[0u, ix])
+    GEPi(bcx, typed_blobptr, [0u, ix])
 }
 
 // Returns a pointer to the body for the box. The box may be an opaque
@@ -376,7 +376,7 @@ fn opaque_box_body(bcx: block,
     let _icx = bcx.insn_ctxt("opaque_box_body");
     let ccx = bcx.ccx();
     let boxptr = PointerCast(bcx, boxptr, T_ptr(T_box_header(ccx)));
-    let bodyptr = GEPi(bcx, boxptr, ~[1u]);
+    let bodyptr = GEPi(bcx, boxptr, [1u]);
     PointerCast(bcx, bodyptr, T_ptr(type_of(ccx, body_t)))
 }
 
@@ -422,7 +422,7 @@ fn malloc_general_dyn(bcx: block, t: ty::t, heap: heap, size: ValueRef)
     let _icx = bcx.insn_ctxt("malloc_general");
     let {bcx: bcx, val: llbox} = malloc_raw_dyn(bcx, t, heap, size);
     let non_gc_box = non_gc_box_cast(bcx, llbox);
-    let body = GEPi(bcx, non_gc_box, ~[0u, abi::box_field_body]);
+    let body = GEPi(bcx, non_gc_box, [0u, abi::box_field_body]);
     return {bcx: bcx, box: llbox, body: body};
 }
 
@@ -732,7 +732,7 @@ fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
         closure::make_fn_glue(bcx, v, t, take_ty)
       }
       ty::ty_trait(_, _, _) => {
-        let llbox = Load(bcx, GEPi(bcx, v, ~[0u, 1u]));
+        let llbox = Load(bcx, GEPi(bcx, v, [0u, 1u]));
         incr_refcnt_of_boxed(bcx, llbox);
         bcx
       }
@@ -752,7 +752,7 @@ fn incr_refcnt_of_boxed(cx: block, box_ptr: ValueRef) {
     let _icx = cx.insn_ctxt("incr_refcnt_of_boxed");
     let ccx = cx.ccx();
     maybe_validate_box(cx, box_ptr);
-    let rc_ptr = GEPi(cx, box_ptr, ~[0u, abi::box_field_refcnt]);
+    let rc_ptr = GEPi(cx, box_ptr, [0u, abi::box_field_refcnt]);
     let rc = Load(cx, rc_ptr);
     let rc = Add(cx, rc, C_int(ccx, 1));
     Store(cx, rc, rc_ptr);
@@ -777,7 +777,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
     let bcx = match ty::get(t).struct {
       ty::ty_box(body_mt) => {
         let v = Load(bcx, v);
-        let body = GEPi(bcx, v, ~[0u, abi::box_field_body]);
+        let body = GEPi(bcx, v, [0u, abi::box_field_body]);
         // Cast away the addrspace of the box pointer.
         let body = PointerCast(bcx, body, T_ptr(type_of(ccx, body_mt.ty)));
         let bcx = drop_ty(bcx, body, body_mt.ty);
@@ -785,8 +785,8 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
       }
       ty::ty_opaque_box => {
         let v = Load(bcx, v);
-        let td = Load(bcx, GEPi(bcx, v, ~[0u, abi::box_field_tydesc]));
-        let valptr = GEPi(bcx, v, ~[0u, abi::box_field_body]);
+        let td = Load(bcx, GEPi(bcx, v, [0u, abi::box_field_tydesc]));
+        let valptr = GEPi(bcx, v, [0u, abi::box_field_body]);
         // Generate code that, dynamically, indexes into the
         // tydesc and calls the drop glue that got set dynamically
         call_tydesc_glue_full(bcx, valptr, td, abi::tydesc_field_drop_glue,
@@ -822,11 +822,11 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
 fn trans_class_drop(bcx: block, v0: ValueRef, dtor_did: ast::def_id,
                     class_did: ast::def_id,
                     substs: &ty::substs) -> block {
-  let drop_flag = GEPi(bcx, v0, ~[0u, 0u]);
+  let drop_flag = GEPi(bcx, v0, [0u, 0u]);
     do with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) |cx| {
     let mut bcx = cx;
       // We have to cast v0
-     let classptr = GEPi(bcx, v0, ~[0u, 1u]);
+     let classptr = GEPi(bcx, v0, [0u, 1u]);
      // Find and call the actual destructor
      let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did, class_did, substs.tps);
      // The second argument is the "self" argument for drop
@@ -843,7 +843,7 @@ fn trans_class_drop(bcx: block, v0: ValueRef, dtor_did: ast::def_id,
      for vec::eachi(ty::class_items_as_mutable_fields(bcx.tcx(), class_did,
                                                       substs))
          |i, fld| {
-        let llfld_a = GEPi(bcx, classptr, ~[0u, i]);
+        let llfld_a = GEPi(bcx, classptr, [0u, i]);
         bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
      }
      Store(bcx, C_u8(0u), drop_flag);
@@ -884,7 +884,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
         closure::make_fn_glue(bcx, v0, t, drop_ty)
       }
       ty::ty_trait(_, _, _) => {
-        let llbox = Load(bcx, GEPi(bcx, v0, ~[0u, 1u]));
+        let llbox = Load(bcx, GEPi(bcx, v0, [0u, 1u]));
         decr_refcnt_maybe_free(bcx, llbox, ty::mk_opaque_box(ccx.tcx))
       }
       ty::ty_opaque_closure_ptr(ck) => {
@@ -940,7 +940,7 @@ fn decr_refcnt_maybe_free(bcx: block, box_ptr: ValueRef, t: ty::t) -> block {
     maybe_validate_box(bcx, box_ptr);
 
     do with_cond(bcx, IsNotNull(bcx, box_ptr)) |bcx| {
-        let rc_ptr = GEPi(bcx, box_ptr, ~[0u, abi::box_field_refcnt]);
+        let rc_ptr = GEPi(bcx, box_ptr, [0u, abi::box_field_refcnt]);
         let rc = Sub(bcx, Load(bcx, rc_ptr), C_int(ccx, 1));
         Store(bcx, rc, rc_ptr);
         let zero_test = ICmp(bcx, lib::llvm::IntEQ, C_int(ccx, 0), rc);
@@ -1046,12 +1046,11 @@ fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef,
 type val_pair_fn = fn@(block, ValueRef, ValueRef) -> block;
 type val_and_ty_fn = fn@(block, ValueRef, ty::t) -> block;
 
-fn load_inbounds(cx: block, p: ValueRef, idxs: ~[uint]) -> ValueRef {
+fn load_inbounds(cx: block, p: ValueRef, idxs: &[uint]) -> ValueRef {
     return Load(cx, GEPi(cx, p, idxs));
 }
 
-fn store_inbounds(cx: block, v: ValueRef, p: ValueRef,
-                  idxs: ~[uint]) {
+fn store_inbounds(cx: block, v: ValueRef, p: ValueRef, idxs: &[uint]) {
     Store(cx, v, GEPi(cx, p, idxs));
 }
 
@@ -1092,7 +1091,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
     match ty::get(t).struct {
       ty::ty_rec(fields) => {
         for vec::eachi(fields) |i, fld| {
-            let llfld_a = GEPi(cx, av, ~[0u, i]);
+            let llfld_a = GEPi(cx, av, [0u, i]);
             cx = f(cx, llfld_a, fld.mt.ty);
         }
       }
@@ -1103,7 +1102,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
       }
       ty::ty_tup(args) => {
         for vec::eachi(args) |i, arg| {
-            let llfld_a = GEPi(cx, av, ~[0u, i]);
+            let llfld_a = GEPi(cx, av, [0u, i]);
             cx = f(cx, llfld_a, arg);
         }
       }
@@ -1120,8 +1119,8 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
         let ccx = cx.ccx();
         let llenumty = T_opaque_enum_ptr(ccx);
         let av_enum = PointerCast(cx, av, llenumty);
-        let lldiscrim_a_ptr = GEPi(cx, av_enum, ~[0u, 0u]);
-        let llunion_a_ptr = GEPi(cx, av_enum, ~[0u, 1u]);
+        let lldiscrim_a_ptr = GEPi(cx, av_enum, [0u, 0u]);
+        let llunion_a_ptr = GEPi(cx, av_enum, [0u, 1u]);
         let lldiscrim_a = Load(cx, lldiscrim_a_ptr);
 
         // NB: we must hit the discriminant first so that structural
@@ -1147,13 +1146,13 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
       ty::ty_class(did, ref substs) => {
           // Take the drop bit into account
           let classptr = if is_some(ty::ty_dtor(cx.tcx(), did)) {
-                  GEPi(cx, av, ~[0u, 1u])
+                  GEPi(cx, av, [0u, 1u])
               }
           else { av };
         for vec::eachi(ty::class_items_as_mutable_fields(cx.tcx(), did,
                                                          substs))
             |i, fld| {
-               let llfld_a = GEPi(cx, classptr, ~[0u, i]);
+               let llfld_a = GEPi(cx, classptr, [0u, i]);
                cx = f(cx, llfld_a, fld.mt.ty);
            }
       }
@@ -1282,7 +1281,7 @@ fn call_tydesc_glue_full(++bcx: block, v: ValueRef, tydesc: ValueRef,
         match static_glue_fn {
           None => {
             // Select out the glue function to call from the tydesc
-            let llfnptr = GEPi(bcx, tydesc, ~[0u, field]);
+            let llfnptr = GEPi(bcx, tydesc, [0u, field]);
             Load(bcx, llfnptr)
           }
           Some(sgf) => sgf
@@ -1880,7 +1879,7 @@ fn autoderef(cx: block, e_id: ast::node_id,
 
         match ty::get(t1).struct {
           ty::ty_box(mt) => {
-            let body = GEPi(cx, v1, ~[0u, abi::box_field_body]);
+            let body = GEPi(cx, v1, [0u, abi::box_field_body]);
             t1 = mt.ty;
 
             // Since we're changing levels of box indirection, we may have
@@ -2603,7 +2602,7 @@ fn trans_var(cx: block, def: ast::def, id: ast::node_id)-> lval_maybe_callee {
             // Nullary variant.
             let enum_ty = node_id_type(cx, id);
             let llenumptr = alloc_ty(cx, enum_ty);
-            let lldiscrimptr = GEPi(cx, llenumptr, ~[0u, 0u]);
+            let lldiscrimptr = GEPi(cx, llenumptr, [0u, 0u]);
             let lldiscrim_gv = lookup_discriminant(ccx, vid);
             let lldiscrim = Load(cx, lldiscrim_gv);
             Store(cx, lldiscrim, lldiscrimptr);
@@ -2664,9 +2663,9 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t,
        (If any other code does the same thing, that's
        a bug */
     let val = if llderef {
-        GEPi(bcx, GEPi(bcx, val, ~[0u, 1u]), ~[0u, ix])
+        GEPi(bcx, GEPi(bcx, val, [0u, 1u]), [0u, ix])
     }
-    else { GEPi(bcx, val, ~[0u, ix]) };
+    else { GEPi(bcx, val, [0u, ix]) };
 
     return {bcx: bcx, val: val, kind: lv_owned};
 }
@@ -2801,11 +2800,11 @@ fn trans_lval(cx: block, e: @ast::expr) -> lval_result {
             let val = match ty::get(t).struct {
               ty::ty_box(_) => {
                 let non_gc_val = non_gc_box_cast(sub.bcx, sub.val);
-                GEPi(sub.bcx, non_gc_val, ~[0u, abi::box_field_body])
+                GEPi(sub.bcx, non_gc_val, [0u, abi::box_field_body])
               }
               ty::ty_uniq(_) => {
                 let non_gc_val = non_gc_box_cast(sub.bcx, sub.val);
-                GEPi(sub.bcx, non_gc_val, ~[0u, abi::box_field_body])
+                GEPi(sub.bcx, non_gc_val, [0u, abi::box_field_body])
               }
               ty::ty_enum(_, _) => {
                 let ety = expr_ty(cx, e);
@@ -2946,7 +2945,7 @@ fn trans_cast(cx: block, e: @ast::expr, id: ast::node_id,
             let cx = e_res.bcx;
             let llenumty = T_opaque_enum_ptr(ccx);
             let av_enum = PointerCast(cx, e_res.val, llenumty);
-            let lldiscrim_a_ptr = GEPi(cx, av_enum, ~[0u, 0u]);
+            let lldiscrim_a_ptr = GEPi(cx, av_enum, [0u, 0u]);
             let lldiscrim_a = Load(cx, lldiscrim_a_ptr);
             match k_out {
               cast_integral => int_cast(e_res.bcx, ll_t_out,
@@ -3103,7 +3102,7 @@ fn adapt_borrowed_value(lv: lval_result,
     match ty::get(e_ty).struct {
       ty::ty_uniq(mt) | ty::ty_box(mt) => {
         let box_ptr = load_value_from_lval_result(lv, e_ty);
-        let body_ptr = GEPi(bcx, box_ptr, ~[0u, abi::box_field_body]);
+        let body_ptr = GEPi(bcx, box_ptr, [0u, abi::box_field_body]);
         let rptr_ty = ty::mk_rptr(bcx.tcx(), ty::re_static, mt);
         return {lv: lval_temp(bcx, body_ptr), ty: rptr_ty};
       }
@@ -3125,8 +3124,8 @@ fn adapt_borrowed_value(lv: lval_result,
                val_str(bcx.ccx().tn, val),
                val_str(bcx.ccx().tn, p));
 
-        Store(bcx, base, GEPi(bcx, p, ~[0u, abi::slice_elt_base]));
-        Store(bcx, len, GEPi(bcx, p, ~[0u, abi::slice_elt_len]));
+        Store(bcx, base, GEPi(bcx, p, [0u, abi::slice_elt_base]));
+        Store(bcx, len, GEPi(bcx, p, [0u, abi::slice_elt_len]));
 
         // this isn't necessarily the type that rust would assign but it's
         // close enough for trans purposes, as it will have the same runtime
@@ -3297,9 +3296,9 @@ fn trans_call_inner(
                 faddr = load_if_immediate(bcx, faddr, fn_expr_ty);
             }
             let pair = faddr;
-            faddr = GEPi(bcx, pair, ~[0u, abi::fn_field_code]);
+            faddr = GEPi(bcx, pair, [0u, abi::fn_field_code]);
             faddr = Load(bcx, faddr);
-            let llclosure = GEPi(bcx, pair, ~[0u, abi::fn_field_box]);
+            let llclosure = GEPi(bcx, pair, [0u, abi::fn_field_box]);
             Load(bcx, llclosure)
           }
         };
@@ -3494,7 +3493,7 @@ fn trans_tup(bcx: block, elts: ~[@ast::expr], dest: dest) -> block {
     };
     let mut temp_cleanups = ~[];
     for vec::eachi(elts) |i, e| {
-        let dst = GEPi(bcx, addr, ~[0u, i]);
+        let dst = GEPi(bcx, addr, [0u, i]);
         let e_ty = expr_ty(bcx, e);
         bcx = trans_expr_save_in(bcx, e, dst);
         add_clean_temp_mem(bcx, dst, e_ty);
@@ -3530,7 +3529,7 @@ fn trans_rec(bcx: block, fields: ~[ast::field],
     for fields.each |fld| {
         let ix = option::get(vec::position(ty_fields,
             |ft| ft.ident == fld.node.ident));
-        let dst = GEPi(bcx, addr, ~[0u, ix]);
+        let dst = GEPi(bcx, addr, [0u, ix]);
         bcx = trans_expr_save_in(bcx, fld.node.expr, dst);
         add_clean_temp_mem(bcx, dst, ty_fields[ix].mt.ty);
         vec::push(temp_cleanups, dst);
@@ -3542,8 +3541,8 @@ fn trans_rec(bcx: block, fields: ~[ast::field],
         // Copy over inherited fields
         for ty_fields.eachi |i, tf| {
             if !vec::any(fields, |f| f.node.ident == tf.ident) {
-                let dst = GEPi(bcx, addr, ~[0u, i]);
-                let base = GEPi(bcx, base_val, ~[0u, i]);
+                let dst = GEPi(bcx, addr, [0u, i]);
+                let base = GEPi(bcx, base_val, [0u, i]);
                 let val = load_if_immediate(bcx, base, tf.mt.ty);
                 bcx = copy_val(bcx, INIT, dst, val, tf.mt.ty);
             }
@@ -3564,10 +3563,10 @@ fn get_struct_field(block_context: block, dest_address: ValueRef,
                     class_id: ast::def_id, index: uint) -> ValueRef {
     if ty::ty_dtor(block_context.tcx(), class_id).is_some() {
         return GEPi(block_context,
-                    GEPi(block_context, dest_address, ~[0, 1]),
-                    ~[0, index]);
+                    GEPi(block_context, dest_address, [0, 1]),
+                    [0, index]);
     }
-    return GEPi(block_context, dest_address, ~[0, index]);
+    return GEPi(block_context, dest_address, [0, index]);
 }
 
 fn trans_struct(block_context: block, span: span, fields: ~[ast::field],
@@ -3615,7 +3614,7 @@ fn trans_struct(block_context: block, span: span, fields: ~[ast::field],
 
     // Add the drop flag if necessary.
     if ty::ty_dtor(block_context.tcx(), class_id).is_some() {
-        let llflagptr = GEPi(block_context, dest_address, ~[0, 0]);
+        let llflagptr = GEPi(block_context, dest_address, [0, 0]);
         Store(block_context, C_u8(1), llflagptr);
     }
 
@@ -3674,7 +3673,7 @@ fn trans_struct(block_context: block, span: span, fields: ~[ast::field],
                                                         i);
                 let llbasefieldvalue = GEPi(block_context,
                                             llbasevalue,
-                                            ~[0, i]);
+                                            [0, i]);
                 let field_type = ty::lookup_field_type(block_context.tcx(),
                                                        class_id,
                                                        class_field.id,
@@ -4964,9 +4963,9 @@ fn trans_enum_variant(ccx: @crate_ctxt,
     } else {
         let llenumptr =
             PointerCast(bcx, fcx.llretptr, T_opaque_enum_ptr(ccx));
-        let lldiscrimptr = GEPi(bcx, llenumptr, ~[0u, 0u]);
+        let lldiscrimptr = GEPi(bcx, llenumptr, [0u, 0u]);
         Store(bcx, C_int(ccx, disr), lldiscrimptr);
-        GEPi(bcx, llenumptr, ~[0u, 1u])
+        GEPi(bcx, llenumptr, [0u, 1u])
     };
     let t_id = local_def(enum_id);
     let v_id = local_def(variant.node.id);
@@ -5023,10 +5022,10 @@ fn trans_class_ctor(ccx: @crate_ctxt, path: path, decl: ast::fn_decl,
                                   parent_id)) {
     // Initialize the drop flag
     let one = C_u8(1u);
-    let flag = GEPi(bcx_top, selfptr, ~[0u, 0u]);
+    let flag = GEPi(bcx_top, selfptr, [0u, 0u]);
     Store(bcx_top, one, flag);
     // Select the pointer to the class itself
-    GEPi(bcx_top, selfptr, ~[0u, 1u])
+    GEPi(bcx_top, selfptr, [0u, 1u])
   }
   else { selfptr };
 
@@ -5039,7 +5038,7 @@ fn trans_class_ctor(ccx: @crate_ctxt, path: path, decl: ast::fn_decl,
   // drop their LHS
     for fields.each |field| {
      let ix = field_idx_strict(bcx.tcx(), sp, field.ident, fields);
-     bcx = zero_mem(bcx, GEPi(bcx, valptr, ~[0u, ix]), field.mt.ty);
+     bcx = zero_mem(bcx, GEPi(bcx, valptr, [0u, ix]), field.mt.ty);
   }
 
   // note we don't want to take *or* drop self.
@@ -5352,9 +5351,9 @@ fn create_real_fn_pair(cx: block, llfnty: TypeRef, llfn: ValueRef,
 fn fill_fn_pair(bcx: block, pair: ValueRef, llfn: ValueRef,
                 llenvptr: ValueRef) {
     let ccx = bcx.ccx();
-    let code_cell = GEPi(bcx, pair, ~[0u, abi::fn_field_code]);
+    let code_cell = GEPi(bcx, pair, [0u, abi::fn_field_code]);
     Store(bcx, llfn, code_cell);
-    let env_cell = GEPi(bcx, pair, ~[0u, abi::fn_field_box]);
+    let env_cell = GEPi(bcx, pair, [0u, abi::fn_field_box]);
     let llenvblobptr = PointerCast(bcx, llenvptr, T_opaque_box_ptr(ccx));
     Store(bcx, llenvblobptr, env_cell);
 }
diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs
index 7a5fb3edfad..b22560d491d 100644
--- a/src/rustc/middle/trans/build.rs
+++ b/src/rustc/middle/trans/build.rs
@@ -431,20 +431,22 @@ fn GEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) -> ValueRef {
 
 // Simple wrapper around GEP that takes an array of ints and wraps them
 // in C_i32()
-fn GEPi(cx: block, base: ValueRef, ixs: ~[uint]) -> ValueRef {
+//
+// XXX: Use a small-vector optimization to avoid allocations here.
+fn GEPi(cx: block, base: ValueRef, ixs: &[uint]) -> ValueRef {
     let mut v: ~[ValueRef] = ~[];
     for vec::each(ixs) |i| { vec::push(v, C_i32(i as i32)); }
     count_insn(cx, "gepi");
     return InBoundsGEP(cx, base, v);
 }
 
-fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: ~[ValueRef]) ->
+fn InBoundsGEP(cx: block, Pointer: ValueRef, Indices: &[ValueRef]) ->
    ValueRef {
     if cx.unreachable { return llvm::LLVMGetUndef(T_ptr(T_nil())); }
     unsafe {
         count_insn(cx, "inboundsgep");
     return llvm::LLVMBuildInBoundsGEP(B(cx), Pointer,
-                                       vec::unsafe::to_ptr(Indices),
+                                       vec::unsafe::to_ptr_slice(Indices),
                                        Indices.len() as c_uint,
                                        noname());
     }
diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs
index 953ad280e46..17424dcc023 100644
--- a/src/rustc/middle/trans/closure.rs
+++ b/src/rustc/middle/trans/closure.rs
@@ -145,7 +145,7 @@ fn allocate_cbox(bcx: block,
         // Initialize ref count to arbitrary value for debugging:
         let ccx = bcx.ccx();
         let llbox = PointerCast(bcx, llbox, T_opaque_box_ptr(ccx));
-        let ref_cnt = GEPi(bcx, llbox, ~[0u, abi::box_field_refcnt]);
+        let ref_cnt = GEPi(bcx, llbox, [0u, abi::box_field_refcnt]);
         let rc = C_int(ccx, 0x12345678);
         Store(bcx, rc, ref_cnt);
     }
@@ -207,8 +207,7 @@ fn store_environment(bcx: block,
                                   ev_to_str(ccx, bv)));
         }
 
-        let bound_data = GEPi(bcx, llbox,
-             ~[0u, abi::box_field_body, i]);
+        let bound_data = GEPi(bcx, llbox, [0u, abi::box_field_body, i]);
         match bv {
           env_copy(val, ty, lv_owned) => {
             let val1 = load_if_immediate(bcx, val, ty);
@@ -326,8 +325,7 @@ fn load_environment(fcx: fn_ctxt,
         match cap_var.mode {
           capture::cap_drop => { /* ignore */ }
           _ => {
-            let mut upvarptr =
-                GEPi(bcx, llcdata, ~[0u, i]);
+            let mut upvarptr = GEPi(bcx, llcdata, [0u, i]);
             match ck {
               ty::ck_block => { upvarptr = Load(bcx, upvarptr); }
               ty::ck_uniq | ty::ck_box => ()
@@ -339,11 +337,9 @@ fn load_environment(fcx: fn_ctxt,
         }
     }
     if load_ret_handle {
-        let flagptr = Load(bcx, GEPi(bcx, llcdata,
-                                     ~[0u, i]));
+        let flagptr = Load(bcx, GEPi(bcx, llcdata, [0u, i]));
         let retptr = Load(bcx,
-                          GEPi(bcx, llcdata,
-                               ~[0u, i+1u]));
+                          GEPi(bcx, llcdata, [0u, i+1u]));
         fcx.loop_ret = Some({flagptr: flagptr, retptr: retptr});
     }
 }
@@ -415,7 +411,7 @@ fn make_fn_glue(
     let tcx = cx.tcx();
 
     let fn_env = fn@(ck: ty::closure_kind) -> block {
-        let box_cell_v = GEPi(cx, v, ~[0u, abi::fn_field_box]);
+        let box_cell_v = GEPi(cx, v, [0u, abi::fn_field_box]);
         let box_ptr_v = Load(cx, box_cell_v);
         do with_cond(cx, IsNotNull(cx, box_ptr_v)) |bcx| {
             let closure_ty = ty::mk_opaque_closure_ptr(tcx, ck);
@@ -459,10 +455,10 @@ fn make_opaque_cbox_take_glue(
     do with_cond(bcx, IsNotNull(bcx, cbox_in)) |bcx| {
         // Load the size from the type descr found in the cbox
         let cbox_in = PointerCast(bcx, cbox_in, llopaquecboxty);
-        let tydescptr = GEPi(bcx, cbox_in, ~[0u, abi::box_field_tydesc]);
+        let tydescptr = GEPi(bcx, cbox_in, [0u, abi::box_field_tydesc]);
         let tydesc = Load(bcx, tydescptr);
         let tydesc = PointerCast(bcx, tydesc, T_ptr(ccx.tydesc_type));
-        let sz = Load(bcx, GEPi(bcx, tydesc, ~[0u, abi::tydesc_field_size]));
+        let sz = Load(bcx, GEPi(bcx, tydesc, [0u, abi::tydesc_field_size]));
 
         // Adjust sz to account for the rust_opaque_box header fields
         let sz = Add(bcx, sz, shape::llsize_of(ccx, T_box_header(ccx)));
@@ -478,11 +474,11 @@ fn make_opaque_cbox_take_glue(
         Store(bcx, cbox_out, cboxptr);
 
         // Take the (deeply cloned) type descriptor
-        let tydesc_out = GEPi(bcx, cbox_out, ~[0u, abi::box_field_tydesc]);
+        let tydesc_out = GEPi(bcx, cbox_out, [0u, abi::box_field_tydesc]);
         let bcx = take_ty(bcx, tydesc_out, ty::mk_type(tcx));
 
         // Take the data in the tuple
-        let cdata_out = GEPi(bcx, cbox_out, ~[0u, abi::box_field_body]);
+        let cdata_out = GEPi(bcx, cbox_out, [0u, abi::box_field_body]);
         call_tydesc_glue_full(bcx, cdata_out, tydesc,
                               abi::tydesc_field_take_glue, None);
         bcx
@@ -524,12 +520,12 @@ fn make_opaque_cbox_free_glue(
         // Load the type descr found in the cbox
         let lltydescty = T_ptr(ccx.tydesc_type);
         let cbox = Load(bcx, cbox);
-        let tydescptr = GEPi(bcx, cbox, ~[0u, abi::box_field_tydesc]);
+        let tydescptr = GEPi(bcx, cbox, [0u, abi::box_field_tydesc]);
         let tydesc = Load(bcx, tydescptr);
         let tydesc = PointerCast(bcx, tydesc, lltydescty);
 
         // Drop the tuple data then free the descriptor
-        let cdata = GEPi(bcx, cbox, ~[0u, abi::box_field_body]);
+        let cdata = GEPi(bcx, cbox, [0u, abi::box_field_body]);
         call_tydesc_glue_full(bcx, cdata, tydesc,
                               abi::tydesc_field_drop_glue, None);
 
diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs
index 12284fe3441..d760e47296e 100644
--- a/src/rustc/middle/trans/foreign.rs
+++ b/src/rustc/middle/trans/foreign.rs
@@ -592,7 +592,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
                     let mut atys = x86_64.arg_tys;
                     let mut attrs = x86_64.attrs;
                     if x86_64.sret {
-                        let llretptr = GEPi(bcx, llargbundle, ~[0u, n]);
+                        let llretptr = GEPi(bcx, llargbundle, [0u, n]);
                         let llretloc = Load(bcx, llretptr);
                         llargvals = ~[llretloc];
                         atys = vec::tail(atys);
@@ -600,15 +600,14 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
                     }
                     while i < n {
                         let llargval = if atys[i].cast {
-                            let arg_ptr = GEPi(bcx, llargbundle,
-                                               ~[0u, i]);
+                            let arg_ptr = GEPi(bcx, llargbundle, [0u, i]);
                             let arg_ptr = BitCast(bcx, arg_ptr,
                                               T_ptr(atys[i].ty));
                             Load(bcx, arg_ptr)
                         } else if option::is_some(attrs[i]) {
-                            GEPi(bcx, llargbundle, ~[0u, i])
+                            GEPi(bcx, llargbundle, [0u, i])
                         } else {
-                            load_inbounds(bcx, llargbundle, ~[0u, i])
+                            load_inbounds(bcx, llargbundle, [0u, i])
                         };
                         vec::push(llargvals, llargval);
                         i += 1u;
@@ -617,7 +616,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
                 _ => {
                     while i < n {
                         let llargval = load_inbounds(bcx, llargbundle,
-                                                          ~[0u, i]);
+                                                          [0u, i]);
                         vec::push(llargvals, llargval);
                         i += 1u;
                     }
@@ -645,7 +644,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
                         return;
                     }
                     let n = vec::len(tys.arg_tys);
-                    let llretptr = GEPi(bcx, llargbundle, ~[0u, n]);
+                    let llretptr = GEPi(bcx, llargbundle, [0u, n]);
                     let llretloc = Load(bcx, llretptr);
                     if x86_64.ret_ty.cast {
                         let tmp_ptr = BitCast(bcx, llretloc,
@@ -659,7 +658,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
                     if tys.ret_def {
                         let n = vec::len(tys.arg_tys);
                         // R** llretptr = &args->r;
-                        let llretptr = GEPi(bcx, llargbundle, ~[0u, n]);
+                        let llretptr = GEPi(bcx, llargbundle, [0u, n]);
                         // R* llretloc = *llretptr; /* (args->r) */
                         let llretloc = Load(bcx, llretptr);
                         // *args->r = r;
@@ -1085,19 +1084,19 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
                         if option::is_some(attrs[i]) {
                             argval = Load(bcx, argval);
                             store_inbounds(bcx, argval, llargbundle,
-                                           ~[0u, i]);
+                                           [0u, i]);
                         } else if atys[i].cast {
-                            let argptr = GEPi(bcx, llargbundle, ~[0u, i]);
+                            let argptr = GEPi(bcx, llargbundle, [0u, i]);
                             let argptr = BitCast(bcx, argptr,
                                                  T_ptr(atys[i].ty));
                             Store(bcx, argval, argptr);
                         } else {
                             store_inbounds(bcx, argval, llargbundle,
-                                           ~[0u, i]);
+                                           [0u, i]);
                         }
                         i += 1u;
                     }
-                    store_inbounds(bcx, llretptr, llargbundle, ~[0u, n]);
+                    store_inbounds(bcx, llretptr, llargbundle, [0u, n]);
                 }
                 _ => {
                     let llretptr = alloca(bcx, tys.ret_ty);
@@ -1105,9 +1104,9 @@ fn trans_foreign_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
                   for uint::range(0u, n) |i| {
                         let llargval = get_param(llwrapfn, i);
                         store_inbounds(bcx, llargval, llargbundle,
-                                                      ~[0u, i]);
+                                                      [0u, i]);
                     };
-                    store_inbounds(bcx, llretptr, llargbundle, ~[0u, n]);
+                    store_inbounds(bcx, llretptr, llargbundle, [0u, n]);
                 }
             }
         }
diff --git a/src/rustc/middle/trans/impl.rs b/src/rustc/middle/trans/impl.rs
index 9c13218ef85..6ffeb861270 100644
--- a/src/rustc/middle/trans/impl.rs
+++ b/src/rustc/middle/trans/impl.rs
@@ -275,18 +275,18 @@ fn trans_trait_callee(bcx: block, val: ValueRef,
     -> lval_maybe_callee {
     let _icx = bcx.insn_ctxt("impl::trans_trait_callee");
     let ccx = bcx.ccx();
-    let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, ~[0u, 0u]),
+    let vtable = Load(bcx, PointerCast(bcx, GEPi(bcx, val, [0u, 0u]),
                                        T_ptr(T_ptr(T_vtable()))));
-    let llbox = Load(bcx, GEPi(bcx, val, ~[0u, 1u]));
+    let llbox = Load(bcx, GEPi(bcx, val, [0u, 1u]));
     // FIXME[impl] I doubt this is alignment-safe (#2534)
-    let self = GEPi(bcx, llbox, ~[0u, abi::box_field_body]);
+    let self = GEPi(bcx, llbox, [0u, abi::box_field_body]);
     let env = self_env(self, ty::mk_opaque_box(bcx.tcx()), Some(llbox),
                        // XXX: is this bogosity?
                        ast::by_ref);
     let llfty = type_of::type_of_fn_from_ty(ccx, callee_ty);
     let vtable = PointerCast(bcx, vtable,
                              T_ptr(T_array(T_ptr(llfty), n_method + 1u)));
-    let mptr = Load(bcx, GEPi(bcx, vtable, ~[0u, n_method]));
+    let mptr = Load(bcx, GEPi(bcx, vtable, [0u, n_method]));
     {bcx: bcx, val: mptr, kind: lv_owned, env: env}
 }
 
@@ -423,12 +423,12 @@ fn trans_cast(bcx: block, val: @ast::expr, id: ast::node_id, dest: dest)
     let bcx = trans_expr_save_in(bcx, val, body);
     revoke_clean(bcx, llbox);
     let result = get_dest_addr(dest);
-    Store(bcx, llbox, PointerCast(bcx, GEPi(bcx, result, ~[0u, 1u]),
+    Store(bcx, llbox, PointerCast(bcx, GEPi(bcx, result, [0u, 1u]),
                                   T_ptr(val_ty(llbox))));
     let orig = ccx.maps.vtable_map.get(id)[0];
     let orig = resolve_vtable_in_fn_ctxt(bcx.fcx, orig);
     let vtable = get_vtable(bcx.ccx(), orig);
-    Store(bcx, vtable, PointerCast(bcx, GEPi(bcx, result, ~[0u, 0u]),
+    Store(bcx, vtable, PointerCast(bcx, GEPi(bcx, result, [0u, 0u]),
                                    T_ptr(val_ty(vtable))));
     bcx
 }
diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs
index dc3715b37b8..523d5b66305 100644
--- a/src/rustc/middle/trans/tvec.rs
+++ b/src/rustc/middle/trans/tvec.rs
@@ -33,23 +33,23 @@ fn expand_boxed_vec_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
 
 fn get_fill(bcx: block, vptr: ValueRef) -> ValueRef {
     let _icx = bcx.insn_ctxt("tvec::get_fill");
-    Load(bcx, GEPi(bcx, vptr, ~[0u, abi::vec_elt_fill]))
+    Load(bcx, GEPi(bcx, vptr, [0u, abi::vec_elt_fill]))
 }
 fn set_fill(bcx: block, vptr: ValueRef, fill: ValueRef) {
-    Store(bcx, fill, GEPi(bcx, vptr, ~[0u, abi::vec_elt_fill]));
+    Store(bcx, fill, GEPi(bcx, vptr, [0u, abi::vec_elt_fill]));
 }
 fn get_alloc(bcx: block, vptr: ValueRef) -> ValueRef {
-    Load(bcx, GEPi(bcx, vptr, ~[0u, abi::vec_elt_alloc]))
+    Load(bcx, GEPi(bcx, vptr, [0u, abi::vec_elt_alloc]))
 }
 
 fn get_bodyptr(bcx: block, vptr: ValueRef) -> ValueRef {
-    non_gc_box_cast(bcx, GEPi(bcx, vptr, ~[0u, abi::box_field_body]))
+    non_gc_box_cast(bcx, GEPi(bcx, vptr, [0u, abi::box_field_body]))
 }
 
 fn get_dataptr(bcx: block, vptr: ValueRef)
     -> ValueRef {
     let _icx = bcx.insn_ctxt("tvec::get_dataptr");
-    GEPi(bcx, vptr, ~[0u, abi::vec_elt_elems, 0u])
+    GEPi(bcx, vptr, [0u, abi::vec_elt_elems, 0u])
 }
 
 fn pointer_add(bcx: block, ptr: ValueRef, bytes: ValueRef) -> ValueRef {
@@ -69,8 +69,8 @@ fn alloc_raw(bcx: block, unit_ty: ty::t,
 
     let {bcx, box, body} =
         base::malloc_general_dyn(bcx, vecbodyty, heap, vecsize);
-    Store(bcx, fill, GEPi(bcx, body, ~[0u, abi::vec_elt_fill]));
-    Store(bcx, alloc, GEPi(bcx, body, ~[0u, abi::vec_elt_alloc]));
+    Store(bcx, fill, GEPi(bcx, body, [0u, abi::vec_elt_fill]));
+    Store(bcx, alloc, GEPi(bcx, body, [0u, abi::vec_elt_alloc]));
     return {bcx: bcx, val: box};
 }
 fn alloc_uniq_raw(bcx: block, unit_ty: ty::t,
@@ -187,8 +187,8 @@ fn trans_evec(bcx: block, elements: evec_elements,
 
             let p = base::alloca(bcx, T_struct(~[T_ptr(llunitty),
                                                 ccx.int_type]));
-            Store(bcx, vp, GEPi(bcx, p, ~[0u, abi::slice_elt_base]));
-            Store(bcx, len, GEPi(bcx, p, ~[0u, abi::slice_elt_len]));
+            Store(bcx, vp, GEPi(bcx, p, [0u, abi::slice_elt_base]));
+            Store(bcx, len, GEPi(bcx, p, [0u, abi::slice_elt_len]));
 
             {bcx: bcx, val: p, dataptr: vp}
           }
@@ -298,14 +298,14 @@ fn get_base_and_len(cx: block, v: ValueRef, e_ty: ty::t)
 
     match vstore {
       ty::vstore_fixed(n) => {
-        let base = GEPi(cx, v, ~[0u, 0u]);
+        let base = GEPi(cx, v, [0u, 0u]);
         let n = if ty::type_is_str(e_ty) { n + 1u } else { n };
         let len = Mul(cx, C_uint(ccx, n), unit_sz);
         (base, len)
       }
       ty::vstore_slice(_) => {
-        let base = Load(cx, GEPi(cx, v, ~[0u, abi::slice_elt_base]));
-        let len = Load(cx, GEPi(cx, v, ~[0u, abi::slice_elt_len]));
+        let base = Load(cx, GEPi(cx, v, [0u, abi::slice_elt_base]));
+        let len = Load(cx, GEPi(cx, v, [0u, abi::slice_elt_len]));
         (base, len)
       }
       ty::vstore_uniq | ty::vstore_box => {
diff --git a/src/rustc/middle/trans/uniq.rs b/src/rustc/middle/trans/uniq.rs
index 1d5d5d6f4fa..214fa0547ae 100644
--- a/src/rustc/middle/trans/uniq.rs
+++ b/src/rustc/middle/trans/uniq.rs
@@ -46,9 +46,9 @@ fn duplicate(bcx: block, v: ValueRef, t: ty::t) -> result {
     let bcx = copy_val(bcx, INIT, dst_body, src_body, content_ty);
 
     let src_tydesc_ptr = GEPi(bcx, src_box,
-                              ~[0u, back::abi::box_field_tydesc]);
+                              [0u, back::abi::box_field_tydesc]);
     let dst_tydesc_ptr = GEPi(bcx, dst_box,
-                              ~[0u, back::abi::box_field_tydesc]);
+                              [0u, back::abi::box_field_tydesc]);
 
     let td = Load(bcx, src_tydesc_ptr);
     Store(bcx, td, dst_tydesc_ptr);