---

yaml
---
r: 83849
b: refs/heads/try
c: 2e1df8e
h: refs/heads/master
i:
  83847: 20e7cc0
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: 95fc31ae9bf8e9f859e6a7ceb43d645ebef33905
+refs/heads/try: 2e1df8e35bb0185dc35f5e7976c0b46608c32404
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rustpkg.md

@@ -137,6 +137,9 @@ and builds it in any workspace(s) where it finds one.
 Supposing such packages are found in workspaces X, Y, and Z,
 the command leaves behind files in `X`'s, `Y`'s, and `Z`'s `build` directories,
 but not in their `lib` or `bin` directories.
+(The exception is when rustpkg fetches a package `foo`'s sources from a remote repository.
+In that case, it stores both the sources *and* the build artifacts for `foo`
+in the workspace that `foo` will install to (see ##install below)).
 
 ## clean
 
@@ -148,7 +151,11 @@ but not in their `lib` or `bin` directories.
 If `RUST_PATH` is declared as an environment variable, then rustpkg installs the
 libraries and executables into the `lib` and `bin` subdirectories
 of the first entry in `RUST_PATH`.
-Otherwise, it installs them into `foo`'s `lib` and `bin` directories.
+Otherwise, if the current working directory CWD is a workspace,
+it installs them into CWD's `lib` and `bin` subdirectories.
+Otherwise, if the current working directory is CWD,
+it installs them into the .rust/lib and .rust/bin subdirectories of CWD
+(creating them if necessary). 
 
 ## test
 

branches/try/src/librustc/middle/trans/cabi.rs

@@ -18,62 +18,10 @@ use middle::trans::cabi_mips;
 use middle::trans::type_::Type;
 use syntax::abi::{X86, X86_64, Arm, Mips};
 
-#[deriving(Clone, Eq)]
-pub enum ArgKind {
-    /// Pass the argument directly using the normal converted
-    /// LLVM type or by coercing to another specified type
-    Direct,
-    /// Pass the argument indirectly via a hidden pointer
-    Indirect
-}
-
-/// Information about how a specific C type
-/// should be passed to or returned from a function
-///
-/// This is borrowed from clang's ABIInfo.h
 #[deriving(Clone)]
-pub struct ArgType {
-    kind: ArgKind,
-    /// Original LLVM type
-    ty: Type,
-    /// Coerced LLVM Type
-    cast: option::Option<Type>,
-    /// Dummy argument, which is emitted before the real argument
-    pad: option::Option<Type>,
-    /// LLVM attribute of argument
-    attr: option::Option<Attribute>
-}
-
-impl ArgType {
-    pub fn direct(ty: Type, cast: option::Option<Type>,
-                            pad: option::Option<Type>,
-                            attr: option::Option<Attribute>) -> ArgType {
-        ArgType {
-            kind: Direct,
-            ty: ty,
-            cast: cast,
-            pad: pad,
-            attr: attr
-        }
-    }
-
-    pub fn indirect(ty: Type, attr: option::Option<Attribute>) -> ArgType {
-        ArgType {
-            kind: Indirect,
-            ty: ty,
-            cast: option::None,
-            pad: option::None,
-            attr: attr
-        }
-    }
-
-    pub fn is_direct(&self) -> bool {
-        return self.kind == Direct;
-    }
-
-    pub fn is_indirect(&self) -> bool {
-        return self.kind == Indirect;
-    }
+pub struct LLVMType {
+    cast: bool,
+    ty: Type
 }
 
 /// Metadata describing how the arguments to a native function
@@ -82,11 +30,22 @@ impl ArgType {
 /// I will do my best to describe this structure, but these
 /// comments are reverse-engineered and may be inaccurate. -NDM
 pub struct FnType {
-    /// The LLVM types of each argument.
-    arg_tys: ~[ArgType],
+    /// The LLVM types of each argument. If the cast flag is true,
+    /// then the argument should be cast, typically because the
+    /// official argument type will be an int and the rust type is i8
+    /// or something like that.
+    arg_tys: ~[LLVMType],
+
+    /// A list of attributes to be attached to each argument (parallel
+    /// the `arg_tys` array). If the attribute for a given is Some,
+    /// then the argument should be passed by reference.
+    attrs: ~[option::Option<Attribute>],
 
     /// LLVM return type.
-    ret_ty: ArgType,
+    ret_ty: LLVMType,
+
+    /// If true, then an implicit pointer should be added for the result.
+    sret: bool
 }
 
 pub fn compute_abi_info(ccx: &mut CrateContext,

branches/try/src/librustc/middle/trans/cabi_arm.rs

@@ -11,14 +11,14 @@
 #[allow(non_uppercase_pattern_statics)];
 
 use lib::llvm::{llvm, Integer, Pointer, Float, Double, Struct, Array};
-use lib::llvm::StructRetAttribute;
-use middle::trans::cabi::{FnType, ArgType};
+use lib::llvm::{Attribute, StructRetAttribute};
+use middle::trans::cabi::{FnType, LLVMType};
 use middle::trans::context::CrateContext;
 
 use middle::trans::type_::Type;
 
 use std::num;
-use std::option::{None, Some};
+use std::option::{Option, None, Some};
 
 fn align_up_to(off: uint, a: uint) -> uint {
     return (off + a - 1u) / a * a;
@@ -85,9 +85,9 @@ fn ty_size(ty: Type) -> uint {
     }
 }
 
-fn classify_ret_ty(ty: Type) -> ArgType {
+fn classify_ret_ty(ty: Type) -> (LLVMType, Option<Attribute>) {
     if is_reg_ty(ty) {
-        return ArgType::direct(ty, None, None, None);
+        return (LLVMType { cast: false, ty: ty }, None);
     }
     let size = ty_size(ty);
     if size <= 4 {
@@ -98,14 +98,14 @@ fn classify_ret_ty(ty: Type) -> ArgType {
         } else {
             Type::i32()
         };
-        return ArgType::direct(ty, Some(llty), None, None);
+        return (LLVMType { cast: true, ty: llty }, None);
     }
-    ArgType::indirect(ty, Some(StructRetAttribute))
+    (LLVMType { cast: false, ty: ty.ptr_to() }, Some(StructRetAttribute))
 }
 
-fn classify_arg_ty(ty: Type) -> ArgType {
+fn classify_arg_ty(ty: Type) -> (LLVMType, Option<Attribute>) {
     if is_reg_ty(ty) {
-        return ArgType::direct(ty, None, None, None);
+        return (LLVMType { cast: false, ty: ty }, None);
     }
     let align = ty_align(ty);
     let size = ty_size(ty);
@@ -114,7 +114,7 @@ fn classify_arg_ty(ty: Type) -> ArgType {
     } else {
         Type::array(&Type::i64(), ((size + 7) / 8) as u64)
     };
-    ArgType::direct(ty, Some(llty), None, None)
+    (LLVMType { cast: true, ty: llty }, None)
 }
 
 fn is_reg_ty(ty: Type) -> bool {
@@ -132,19 +132,32 @@ pub fn compute_abi_info(_ccx: &mut CrateContext,
                         rty: Type,
                         ret_def: bool) -> FnType {
     let mut arg_tys = ~[];
+    let mut attrs = ~[];
     for &aty in atys.iter() {
-        let ty = classify_arg_ty(aty);
+        let (ty, attr) = classify_arg_ty(aty);
         arg_tys.push(ty);
+        attrs.push(attr);
     }
 
-    let ret_ty = if ret_def {
+    let (ret_ty, ret_attr) = if ret_def {
         classify_ret_ty(rty)
     } else {
-        ArgType::direct(Type::void(), None, None, None)
+        (LLVMType { cast: false, ty: Type::void() }, None)
     };
 
+    let mut ret_ty = ret_ty;
+
+    let sret = ret_attr.is_some();
+    if sret {
+        arg_tys.unshift(ret_ty);
+        attrs.unshift(ret_attr);
+        ret_ty = LLVMType { cast: false, ty: Type::void() };
+    }
+
     return FnType {
         arg_tys: arg_tys,
         ret_ty: ret_ty,
+        attrs: attrs,
+        sret: sret
     };
 }

branches/try/src/librustc/middle/trans/cabi_mips.rs

@@ -12,8 +12,9 @@
 
 use std::libc::c_uint;
 use std::num;
+use std::vec;
 use lib::llvm::{llvm, Integer, Pointer, Float, Double, Struct, Array};
-use lib::llvm::StructRetAttribute;
+use lib::llvm::{Attribute, StructRetAttribute};
 use middle::trans::context::CrateContext;
 use middle::trans::context::task_llcx;
 use middle::trans::cabi::*;
@@ -85,15 +86,15 @@ fn ty_size(ty: Type) -> uint {
     }
 }
 
-fn classify_ret_ty(ty: Type) -> ArgType {
-    if is_reg_ty(ty) {
-        ArgType::direct(ty, None, None, None)
+fn classify_ret_ty(ty: Type) -> (LLVMType, Option<Attribute>) {
+    return if is_reg_ty(ty) {
+        (LLVMType { cast: false, ty: ty }, None)
     } else {
-        ArgType::indirect(ty, Some(StructRetAttribute))
-    }
+        (LLVMType { cast: false, ty: ty.ptr_to() }, Some(StructRetAttribute))
+    };
 }
 
-fn classify_arg_ty(ty: Type, offset: &mut uint) -> ArgType {
+fn classify_arg_ty(ty: Type, offset: &mut uint) -> (LLVMType, Option<Attribute>) {
     let orig_offset = *offset;
     let size = ty_size(ty) * 8;
     let mut align = ty_align(ty);
@@ -102,16 +103,20 @@ fn classify_arg_ty(ty: Type, offset: &mut uint) -> ArgType {
     *offset = align_up_to(*offset, align);
     *offset += align_up_to(size, align * 8) / 8;
 
-    if is_reg_ty(ty) {
-        ArgType::direct(ty, None, None, None)
+    let padding = padding_ty(align, orig_offset);
+    return if !is_reg_ty(ty) {
+        (LLVMType {
+            cast: true,
+            ty: struct_ty(ty, padding, true)
+        }, None)
+    } else if padding.is_some() {
+        (LLVMType {
+            cast: true,
+            ty: struct_ty(ty, padding, false)
+        }, None)
     } else {
-        ArgType::direct(
-            ty,
-            Some(struct_ty(ty)),
-            padding_ty(align, orig_offset),
-            None
-        )
-    }
+        (LLVMType { cast: false, ty: ty }, None)
+    };
 }
 
 fn is_reg_ty(ty: Type) -> bool {
@@ -152,33 +157,54 @@ fn coerce_to_int(size: uint) -> ~[Type] {
     args
 }
 
-fn struct_ty(ty: Type) -> Type {
+fn struct_ty(ty: Type,
+             padding: Option<Type>,
+             coerce: bool) -> Type {
     let size = ty_size(ty) * 8;
-    let fields = coerce_to_int(size);
+    let mut fields = padding.map_default(~[], |p| ~[p]);
+
+    if coerce {
+        fields = vec::append(fields, coerce_to_int(size));
+    } else {
+        fields.push(ty);
+    }
+
     return Type::struct_(fields, false);
 }
 
 pub fn compute_abi_info(_ccx: &mut CrateContext,
                         atys: &[Type],
                         rty: Type,
                         ret_def: bool) -> FnType {
-    let ret_ty = if ret_def {
+    let (ret_ty, ret_attr) = if ret_def {
         classify_ret_ty(rty)
     } else {
-        ArgType::direct(Type::void(), None, None, None)
+        (LLVMType { cast: false, ty: Type::void() }, None)
     };
 
-    let sret = ret_ty.is_indirect();
+    let mut ret_ty = ret_ty;
+
+    let sret = ret_attr.is_some();
     let mut arg_tys = ~[];
+    let mut attrs = ~[];
     let mut offset = if sret { 4 } else { 0 };
 
     for aty in atys.iter() {
-        let ty = classify_arg_ty(*aty, &mut offset);
+        let (ty, attr) = classify_arg_ty(*aty, &mut offset);
         arg_tys.push(ty);
+        attrs.push(attr);
     };
 
+    if sret {
+        arg_tys = vec::append(~[ret_ty], arg_tys);
+        attrs = vec::append(~[ret_attr], attrs);
+        ret_ty = LLVMType { cast: false, ty: Type::void() };
+    }
+
     return FnType {
         arg_tys: arg_tys,
         ret_ty: ret_ty,
+        attrs: attrs,
+        sret: sret
     };
 }