---

yaml
---
r: 44725
b: refs/heads/master
c: 046fc5e
h: refs/heads/master
i:
  44723: 195ad17
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9616b3d11ed947d6bf284bbc088ffc047824203f
+refs/heads/master: 046fc5e0b18921a55d19922865e5f65a98ab0f56
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/AUTHORS.txt

@@ -93,6 +93,7 @@ Josh Matthews <[email protected]>
 Joshua Clark <[email protected]>
 Joshua Wise <[email protected]>
 Jyun-Yan You <[email protected]>
+Kang Seonghoon <[email protected]>
 Kelly Wilson <[email protected]>
 Kevin Atkinson <[email protected]>
 Kevin Cantu <[email protected]>

trunk/src/librustc/lib/llvm.rs

@@ -1379,7 +1379,12 @@ pub fn type_to_str_inner(names: @TypeNames, +outer0: &[TypeRef], ty: TypeRef)
                         type_to_str_inner(names, outer, out_ty)).to_managed();
           }
           Struct => {
-            let elts = struct_tys(ty);
+            let n_elts = llvm::LLVMCountStructElementTypes(ty) as uint;
+            let mut elts = vec::from_elem(n_elts, 0 as TypeRef);
+            if !elts.is_empty() {
+                llvm::LLVMGetStructElementTypes(
+                    ty, ptr::to_mut_unsafe_ptr(&mut elts[0]));
+            }
             // See [Note at-str]
             return fmt!("{%s}", tys_str(names, outer, elts)).to_managed();
           }
@@ -1440,16 +1445,17 @@ pub fn fn_ty_param_tys(fn_ty: TypeRef) -> ~[TypeRef] {
     }
 }
 
-pub fn struct_tys(struct_ty: TypeRef) -> ~[TypeRef] {
+pub fn struct_element_types(struct_ty: TypeRef) -> ~[TypeRef] {
     unsafe {
-        let n_elts = llvm::LLVMCountStructElementTypes(struct_ty) as uint;
-        if n_elts == 0 {
-            return ~[];
+        let count = llvm::LLVMCountStructElementTypes(struct_ty);
+        let mut buf: ~[TypeRef] =
+            vec::from_elem(count as uint,
+                           cast::transmute::<uint,TypeRef>(0));
+        if buf.len() > 0 {
+            llvm::LLVMGetStructElementTypes(
+                struct_ty, ptr::to_mut_unsafe_ptr(&mut buf[0]));
         }
-        let mut elts = vec::from_elem(n_elts, ptr::null());
-        llvm::LLVMGetStructElementTypes(
-            struct_ty, ptr::to_mut_unsafe_ptr(&mut elts[0]));
-        return elts;
+        return buf;
     }
 }
 

trunk/src/librustc/middle/trans/base.rs

@@ -2171,6 +2171,11 @@ pub fn trans_mod(ccx: @CrateContext, m: ast::_mod) {
     }
 }
 
+pub fn get_pair_fn_ty(llpairty: TypeRef) -> TypeRef {
+    // Bit of a kludge: pick the fn typeref out of the pair.
+    return struct_elt(llpairty, 0u);
+}
+
 pub fn register_fn(ccx: @CrateContext,
                    sp: span,
                    +path: path,

trunk/src/librustc/middle/trans/cabi_x86_64.rs

@@ -14,7 +14,6 @@
 use lib::llvm::{llvm, TypeRef, ValueRef, Integer, Pointer, Float, Double};
 use lib::llvm::{Struct, Array, Attribute};
 use lib::llvm::{StructRetAttribute, ByValAttribute};
-use lib::llvm::struct_tys;
 use middle::trans::common::*;
 use middle::trans::cabi::*;
 
@@ -66,6 +65,19 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
         return (off + a - 1u) / a * a;
     }
 
+    fn struct_tys(ty: TypeRef) -> ~[TypeRef] {
+        unsafe {
+            let n = llvm::LLVMCountStructElementTypes(ty);
+        if (n == 0) {
+            return ~[];
+        }
+            let mut elts = vec::from_elem(n as uint, ptr::null());
+            llvm::LLVMGetStructElementTypes(ty,
+                ptr::to_mut_unsafe_ptr(&mut elts[0]));
+            return elts;
+        }
+    }
+
     fn ty_align(ty: TypeRef) -> uint {
         unsafe {
             return match llvm::LLVMGetTypeKind(ty) {

trunk/src/librustc/middle/trans/callee.rs

@@ -380,7 +380,7 @@ pub fn trans_rtcall_or_lang_call_with_type_params(bcx: block,
                                                     fty);
                     let mut llfnty = type_of::type_of(callee.bcx.ccx(),
                                                       substituted);
-                    llfnty = lib::llvm::struct_tys(llfnty)[0];
+                    llfnty = T_ptr(struct_elt(llfnty, 0));
                     new_llval = PointerCast(callee.bcx, fn_data.llfn, llfnty);
                 }
                 _ => fail!()

trunk/src/librustc/middle/trans/common.rs

@@ -647,6 +647,19 @@ pub fn val_str(tn: @TypeNames, v: ValueRef) -> @str {
     return ty_str(tn, val_ty(v));
 }
 
+// Returns the nth element of the given LLVM structure type.
+pub fn struct_elt(llstructty: TypeRef, n: uint) -> TypeRef {
+    unsafe {
+        let elt_count = llvm::LLVMCountStructElementTypes(llstructty) as uint;
+        assert (n < elt_count);
+        let mut elt_tys = vec::from_elem(elt_count, T_nil());
+        llvm::LLVMGetStructElementTypes(
+            llstructty,
+            ptr::to_mut_unsafe_ptr(&mut elt_tys[0]));
+        return llvm::LLVMGetElementType(elt_tys[n]);
+    }
+}
+
 pub fn in_scope_cx(cx: block, f: &fn(&mut scope_info)) {
     let mut cur = cx;
     loop {