Merge branch 'wip_unsized_types'

cc rust-lang#14

Author: bjorn3

build.sh

@@ -41,4 +41,4 @@ gcc target/out/mini_core.o target/out/mini_core_hello_world.o -o target/out/mini
 ./target/out/mini_core_hello_world
 
 $RUSTC target/libcore/src/libcore/lib.rs --color=always --crate-type lib -Cincremental=target/incremental 2>&1 | (head -n 20; echo "===="; tail -n 1000)
-cat target/out/log.txt | sort | uniq -c | grep -v "rval unsize move" | grep -v "rval len"
+cat target/out/log.txt | sort | uniq -c

examples/example.rs

@@ -141,9 +141,9 @@ unsafe fn call_uninit() -> u8 {
 }
 
 // TODO: enable when fat pointers are supported
-/*unsafe fn deref_str_ptr(s: *const str) -> &'static str {
+unsafe fn deref_str_ptr(s: *const str) -> &'static str {
     &*s
-}*/
+}
 
 fn use_array(arr: [u8; 3]) -> u8 {
     arr[1]
@@ -153,6 +153,10 @@ fn repeat_array() -> [u8; 3] {
     [0; 3]
 }
 
+fn array_as_slice(arr: &[u8; 3]) -> &[u8] {
+    arr
+}
+
 /*unsafe fn use_ctlz_nonzero(a: u16) -> u16 {
     intrinsics::ctlz_nonzero(a)
 }*/
@@ -176,3 +180,7 @@ fn make_array() -> [u8; 3] {
 fn some_promoted_tuple() -> &'static (&'static str, &'static str) {
     &("abc", "some")
 }
+
+fn index_slice(s: &[u8]) -> u8 {
+    s[2]
+}

examples/mini_core.rs

@@ -207,3 +207,11 @@ impl<T> Index<usize> for [T; 3] {
         &self[index]
     }
 }
+
+impl<T> Index<usize> for [T] {
+    type Output = T;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self[index]
+    }
+}

examples/mini_core_hello_world.rs

@@ -43,7 +43,8 @@ static NUM_REF: &'static u8 = unsafe { &NUM };
 
 fn main() {
     unsafe {
-        let (ptr, _): (*const u8, usize) = intrinsics::transmute("Hello!\0");
+        let slice: &[u8] = b"Hello!\0" as &[u8; 7];
+        let ptr: *const u8 = slice as *const [u8] as *const u8;
         puts(ptr);
     }
 

src/abi.rs

@@ -28,6 +28,11 @@ fn get_pass_mode<'a, 'tcx: 'a>(
     ty: Ty<'tcx>,
     is_return: bool,
 ) -> PassMode {
+    assert!(
+        !tcx.layout_of(ParamEnv::reveal_all().and(ty))
+            .unwrap()
+            .is_unsized()
+    );
     if ty.sty == tcx.mk_nil().sty {
         if is_return {
             //if false {
@@ -312,7 +317,7 @@ pub fn codegen_fn_prelude<'a, 'tcx: 'a>(
             //unimplemented!("pass mode nopass");
             fx.local_map.insert(
                 RETURN_PLACE,
-                CPlace::Addr(null, fx.layout_of(fx.return_type())),
+                CPlace::Addr(null, None, fx.layout_of(fx.return_type())),
             );
         }
         PassMode::ByVal(ret_ty) => {
@@ -321,8 +326,10 @@ pub fn codegen_fn_prelude<'a, 'tcx: 'a>(
                 .insert(RETURN_PLACE, CPlace::Var(RETURN_PLACE, ret_layout));
         }
         PassMode::ByRef => {
-            fx.local_map
-                .insert(RETURN_PLACE, CPlace::Addr(ret_param.unwrap(), ret_layout));
+            fx.local_map.insert(
+                RETURN_PLACE,
+                CPlace::Addr(ret_param.unwrap(), None, ret_layout),
+            );
         }
     }
 

src/base.rs

@@ -309,8 +309,7 @@ fn trans_stmt<'a, 'tcx: 'a>(
                 }
                 Rvalue::Ref(_, _, place) => {
                     let place = trans_place(fx, place);
-                    let addr = place.expect_addr();
-                    lval.write_cvalue(fx, CValue::ByVal(addr, dest_layout));
+                    place.write_place_ref(fx, lval);
                 }
                 Rvalue::BinaryOp(bin_op, lhs, rhs) => {
                     let ty = fx.monomorphize(&lhs.ty(&fx.mir.local_decls, fx.tcx));
@@ -459,7 +458,8 @@ fn trans_stmt<'a, 'tcx: 'a>(
                     unimplemented!("rval closure_fn_ptr {:?} {:?}", operand, ty)
                 }
                 Rvalue::Cast(CastKind::Unsize, operand, ty) => {
-                    unimpl!("rval unsize {:?} {:?}", operand, ty);
+                    let operand = trans_operand(fx, operand);
+                    operand.unsize_value(fx, lval);
                 }
                 Rvalue::Discriminant(place) => {
                     let place = trans_place(fx, place).to_cvalue(fx);
@@ -474,7 +474,15 @@ fn trans_stmt<'a, 'tcx: 'a>(
                         to.write_cvalue(fx, operand);
                     }
                 }
-                Rvalue::Len(lval) => unimpl!("rval len {:?}", lval),
+                Rvalue::Len(place) => {
+                    let place = trans_place(fx, place);
+                    let size = match place {
+                        CPlace::Addr(_, size, _) => size.unwrap(),
+                        CPlace::Var(_, _) => unreachable!(),
+                    };
+                    let usize_layout = fx.layout_of(fx.tcx.types.usize);
+                    lval.write_cvalue(fx, CValue::ByVal(size, usize_layout));
+                }
                 Rvalue::NullaryOp(NullOp::Box, ty) => unimplemented!("rval box {:?}", ty),
                 Rvalue::NullaryOp(NullOp::SizeOf, ty) => {
                     assert!(
@@ -893,13 +901,7 @@ pub fn trans_place<'a, 'tcx: 'a>(
         Place::Projection(projection) => {
             let base = trans_place(fx, &projection.base);
             match projection.elem {
-                ProjectionElem::Deref => {
-                    let layout = fx.layout_of(place.ty(&*fx.mir, fx.tcx).to_ty(fx.tcx));
-                    if layout.is_unsized() {
-                        unimpl!("Unsized places are not yet implemented");
-                    }
-                    CPlace::Addr(base.to_cvalue(fx).load_value(fx), layout)
-                }
+                ProjectionElem::Deref => base.place_deref(fx),
                 ProjectionElem::Field(field, _ty) => base.place_field(fx, field),
                 ProjectionElem::Index(local) => {
                     let index = fx.get_local_place(local).to_cvalue(fx).load_value(fx);