---

yaml
---
r: 40655
b: refs/heads/dist-snap
c: aa3aa3b
h: refs/heads/master
i:
  40653: 9376d99
  40651: c55cef8
  40647: 78f0048
  40639: 27ea85b
v: v3

Author: pcwalton

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: 32ce61f947ebb1076c1fa2cd49e5d017b6ea1a0a
+refs/heads/dist-snap: aa3aa3b1b2b6d648af35122905d4958ad72377fb
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/middle/trans/expr.rs

@@ -1003,8 +1003,8 @@ fn trans_index(bcx: block,
     // Translate index expression and cast to a suitable LLVM integer.
     // Rust is less strict than LLVM in this regard.
     let Result {bcx, val: ix_val} = trans_to_datum(bcx, idx).to_result();
-    let ix_size = shape::llsize_of_real(bcx.ccx(), val_ty(ix_val));
-    let int_size = shape::llsize_of_real(bcx.ccx(), ccx.int_type);
+    let ix_size = machine::llbitsize_of_real(bcx.ccx(), val_ty(ix_val));
+    let int_size = machine::llbitsize_of_real(bcx.ccx(), ccx.int_type);
     let ix_val = {
         if ix_size < int_size {
             if ty::type_is_signed(expr_ty(bcx, idx)) {

branches/dist-snap/src/librustc/middle/trans/foreign.rs

@@ -961,16 +961,17 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item,
             let tp_ty = substs.tys[0];
             let lltp_ty = type_of::type_of(ccx, tp_ty);
             let llout_ty = type_of::type_of(ccx, substs.tys[1]);
-            let tp_sz = shape::llsize_of_real(ccx, lltp_ty),
-            out_sz = shape::llsize_of_real(ccx, llout_ty);
+            let tp_sz = machine::llbitsize_of_real(ccx, lltp_ty),
+            out_sz = machine::llbitsize_of_real(ccx, llout_ty);
           if tp_sz != out_sz {
               let sp = match ccx.tcx.items.get(ref_id.get()) {
                   ast_map::node_expr(e) => e.span,
                   _ => fail ~"reinterpret_cast or forget has non-expr arg"
               };
               ccx.sess.span_fatal(
                   sp, fmt!("reinterpret_cast called on types \
-                            with different size: %s (%u) to %s (%u)",
+                            with different size: %s (%u bit(s)) to %s \
+                            (%u bit(s))",
                            ty_to_str(ccx.tcx, tp_ty), tp_sz,
                            ty_to_str(ccx.tcx, substs.tys[1]), out_sz));
           }

branches/dist-snap/src/librustc/middle/trans/machine.rs

@@ -87,7 +87,10 @@ pub fn llsize_of_alloc(cx: @crate_ctxt, t: TypeRef) -> uint {
 // bits in this number of bytes actually carry data related to the datum
 // with the type. Not junk, padding, accidentally-damaged words, or
 // whatever. Rounds up to the nearest byte though, so if you have a 1-bit
-// value, we return 1 here, not 0. Most of rustc works in bytes.
+// value, we return 1 here, not 0. Most of rustc works in bytes. Be warned
+// that LLVM *does* distinguish between e.g. a 1-bit value and an 8-bit value
+// at the codegen level! In general you should prefer `llbitsize_of_real`
+// below.
 pub fn llsize_of_real(cx: @crate_ctxt, t: TypeRef) -> uint {
     let nbits = llvm::LLVMSizeOfTypeInBits(cx.td.lltd, t) as uint;
     if nbits & 7u != 0u {
@@ -98,6 +101,11 @@ pub fn llsize_of_real(cx: @crate_ctxt, t: TypeRef) -> uint {
     }
 }
 
+/// Returns the "real" size of the type in bits.
+pub fn llbitsize_of_real(cx: @crate_ctxt, t: TypeRef) -> uint {
+    llvm::LLVMSizeOfTypeInBits(cx.td.lltd, t) as uint
+}
+
 // Returns the "default" size of t, which is calculated by casting null to a
 // *T and then doing gep(1) on it and measuring the result. Really, look in
 // the LLVM sources. It does that. So this is likely similar to the ABI size

branches/dist-snap/src/librustc/middle/trans/monomorphize.rs

@@ -329,7 +329,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
                         !ty::type_needs_drop(ccx.tcx, subst)
                     {
                         let llty = type_of::type_of(ccx, subst);
-                        let size = shape::llsize_of_real(ccx, llty);
+                        let size = machine::llbitsize_of_real(ccx, llty);
                         let align = shape::llalign_of_pref(ccx, llty);
                         let mode = datum::appropriate_mode(subst);
 
@@ -344,7 +344,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
 
                         // Special value for nil to prevent problems
                         // with undef return pointers.
-                        if size == 1u && ty::type_is_nil(subst) {
+                        if size <= 8u && ty::type_is_nil(subst) {
                             mono_repr(0u, 0u, is_float, mode)
                         } else {
                             mono_repr(size, align, is_float, mode)

branches/dist-snap/src/test/run-pass/type-use-i1-versus-i8.rs

@@ -0,0 +1,11 @@
+use io::ReaderUtil;
+fn main() {
+    let mut x: bool = false;
+    // this line breaks it
+    vec::rusti::move_val_init(&mut x, false);
+
+    let input = io::stdin();
+    let line = input.read_line(); // use core's io again
+
+    io::println(fmt!("got %?", line));
+}