---

yaml
---
r: 15717
b: refs/heads/try
c: 1135496
h: refs/heads/master
i:
  15715: db1d4c4
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 1e410f6206cee9f75cc156fba1e467cad8f16fdc
+refs/heads/try: 11354963b3c532f0e4465be62191772398c14c70
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/rustc/lib/llvm.rs

@@ -766,6 +766,7 @@ native mod llvm {
     fn LLVMAddTargetData(TD: TargetDataRef, PM: PassManagerRef);
     /** Returns the size of a type. FIXME: rv is actually a C_Ulonglong! */
     fn LLVMStoreSizeOfType(TD: TargetDataRef, Ty: TypeRef) -> c_uint;
+    fn LLVMABISizeOfType(TD: TargetDataRef, Ty: TypeRef) -> c_uint;
     /** Returns the preferred alignment of a type. */
     fn LLVMPreferredAlignmentOfType(TD: TargetDataRef,
                                     Ty: TypeRef) -> c_uint;

branches/try/src/rustc/middle/trans/native.rs

@@ -81,6 +81,10 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
                     uint::max(a, ty_align(t))
                 }
             }
+            11 /* array */ {
+                let elt = llvm::LLVMGetElementType(ty);
+                ty_align(elt)
+            }
             _ {
                 fail "ty_size: unhandled type"
             }
@@ -100,6 +104,12 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
                     s + ty_size(t)
                 }
             }
+            11 /* array */ {
+              let len = llvm::LLVMGetArrayLength(ty) as uint;
+              let elt = llvm::LLVMGetElementType(ty);
+              let eltsz = ty_size(elt);
+              len * eltsz
+            }
             _ {
                 fail "ty_size: unhandled type"
             }
@@ -187,6 +197,16 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
             10 /* struct */ {
                 classify_struct(struct_tys(ty), cls, i, off);
             }
+            11 /* array */ {
+              // FIXME: I HAVE NO IDEA WHAT I AM DOING THIS MUST BE WRONG
+              let len = llvm::LLVMGetArrayLength(ty) as uint;
+              if len == 0u {
+              } else {
+                  let elt = llvm::LLVMGetElementType(ty);
+                  let tys = vec::from_elem(len, elt);
+                  classify_struct(tys, cls, i, off);
+              }
+            }
             _ {
                 fail "classify: unhandled type";
             }

branches/try/src/rustc/middle/trans/shape.rs

@@ -630,6 +630,10 @@ fn llsize_of_real(cx: @crate_ctxt, t: TypeRef) -> uint {
     ret llvm::LLVMStoreSizeOfType(cx.td.lltd, t) as uint;
 }
 
+fn llsize_of_alloc(cx: @crate_ctxt, t: TypeRef) -> uint {
+    ret llvm::LLVMABISizeOfType(cx.td.lltd, t) as uint;
+}
+
 // Returns the preferred alignment of the given type for the current target.
 // The preffered alignment may be larger than the alignment used when
 // packing the type into structs

branches/try/src/test/run-pass/native-struct.rs

@@ -0,0 +1,10 @@
+// Passing enums by value
+
+enum void { }
+
+#[nolink]
+native mod bindgen {
+    fn printf(++v: void);
+}
+
+fn main() { }