---

yaml
---
r: 66475
b: refs/heads/master
c: b883d6a
h: refs/heads/master
i:
  66473: fee584c
  66471: e091959
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b4bb36490d10a9d2613448215f2436f258e7fd28
+refs/heads/master: b883d6a54c460f8357b1107b3599108eb1f8580b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/etc/ctags.rust

@@ -8,4 +8,3 @@
 --regex-rust=/[ \t]*static[ \t]+([a-zA-Z0-9_]+)/\1/m,consts/
 --regex-rust=/[ \t]*trait[ \t]+([a-zA-Z0-9_]+)/\1/m,traits/
 --regex-rust=/[ \t]*impl[ \t]+([a-zA-Z0-9_]+)/\1/m,impls/
---regex-rust=/[ \t]*macro_rules![ \t]+([a-zA-Z0-9_]+)/\1/m,macros/

trunk/src/librust/rust.rs

@@ -238,12 +238,6 @@ fn usage() {
 
 pub fn main() {
     let os_args = os::args();
-
-    if (os_args.len() > 1 && (os_args[1] == ~"-v" || os_args[1] == ~"--version")) {
-        rustc::version(os_args[0]);
-        unsafe { exit(0); }
-    }
-
     let args = os_args.tail();
 
     if !args.is_empty() {

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

@@ -41,6 +41,7 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
             callee::trans_arg_expr(bcx,
                                    expr_ty(bcx, out),
                                    ty::ByCopy,
+                                   ast::sty_static,
                                    out,
                                    &mut cleanups,
                                    None,
@@ -56,6 +57,7 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
             callee::trans_arg_expr(bcx,
                                    expr_ty(bcx, e),
                                    ty::ByCopy,
+                                   ast::sty_static,
                                    e,
                                    &mut cleanups,
                                    None,
@@ -77,6 +79,7 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block {
             callee::trans_arg_expr(bcx,
                                    expr_ty(bcx, in),
                                    ty::ByCopy,
+                                   ast::sty_static,
                                    in,
                                    &mut cleanups,
                                    None,

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

@@ -1626,11 +1626,18 @@ pub fn create_llargs_for_fn_args(cx: fn_ctxt,
     let _icx = push_ctxt("create_llargs_for_fn_args");
 
     match self_arg {
-      impl_self(tt, self_mode) => {
+      impl_self(tt) => {
         cx.llself = Some(ValSelfData {
             v: cx.llenv,
             t: tt,
-            is_copy: self_mode == ty::ByCopy
+            is_owned: false
+        });
+      }
+      impl_owned_self(tt) => {
+        cx.llself = Some(ValSelfData {
+            v: cx.llenv,
+            t: tt,
+            is_owned: true
         });
       }
       no_self => ()
@@ -1669,18 +1676,12 @@ pub fn copy_args_to_allocas(fcx: fn_ctxt,
 
     match fcx.llself {
         Some(slf) => {
-            let self_val = if slf.is_copy
-                    && datum::appropriate_mode(slf.t).is_by_value() {
-                let tmp = BitCast(bcx, slf.v, type_of(bcx.ccx(), slf.t));
-                let alloc = alloc_ty(bcx, slf.t);
-                Store(bcx, tmp, alloc);
-                alloc
-            } else {
-                PointerCast(bcx, slf.v, type_of(bcx.ccx(), slf.t).ptr_to())
-            };
-
+            let self_val = PointerCast(bcx, slf.v, type_of(bcx.ccx(), slf.t).ptr_to());
             fcx.llself = Some(ValSelfData {v: self_val, ..slf});
-            add_clean(bcx, self_val, slf.t);
+
+            if slf.is_owned {
+                add_clean(bcx, slf.v, slf.t);
+            }
         }
         _ => {}
     }
@@ -1757,7 +1758,7 @@ pub fn tie_up_header_blocks(fcx: fn_ctxt, lltop: BasicBlockRef) {
     }
 }
 
-pub enum self_arg { impl_self(ty::t, ty::SelfMode), no_self, }
+pub enum self_arg { impl_self(ty::t), impl_owned_self(ty::t), no_self, }
 
 // trans_closure: Builds an LLVM function out of a source function.
 // If the function closes over its environment a closure will be

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

@@ -126,10 +126,11 @@ fn classify_ty(ty: Type) -> ~[RegClass] {
             Float => 4,
             Double => 8,
             Struct => {
-                let str_tys = ty.field_types();
                 if ty.is_packed() {
+                    let str_tys = ty.field_types();
                     str_tys.iter().fold(0, |s, t| s + ty_size(*t))
                 } else {
+                    let str_tys = ty.field_types();
                     let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
                     align(size, ty)
                 }
@@ -239,7 +240,9 @@ fn classify_ty(ty: Type) -> ~[RegClass] {
         let mut i = 0u;
         let ty_kind = ty.kind();
         let e = cls.len();
-        if cls.len() > 2u && (ty_kind == Struct || ty_kind == Array) {
+        if cls.len() > 2u &&
+           (ty_kind == Struct ||
+            ty_kind == Array) {
             if cls[i].is_sse() {
                 i += 1u;
                 while i < e {
@@ -266,7 +269,7 @@ fn classify_ty(ty: Type) -> ~[RegClass] {
                     return;
                 }
                 if cls[i] == SSEUp {
-                    cls[i] = SSEDv;
+                    cls[i] = SSEInt;
                 } else if cls[i].is_sse() {
                     i += 1;
                     while i != e && cls[i] == SSEUp { i += 1u; }
@@ -284,6 +287,7 @@ fn classify_ty(ty: Type) -> ~[RegClass] {
     let mut cls = vec::from_elem(words, NoClass);
     if words > 4 {
         all_mem(cls);
+        let cls = cls;
         return cls;
     }
     classify(ty, cls, 0, 0);
@@ -312,8 +316,8 @@ fn llreg_ty(cls: &[RegClass]) -> Type {
                 tys.push(Type::i64());
             }
             SSEFv => {
-                let vec_len = llvec_len(cls.tailn(i + 1u));
-                let vec_ty = Type::vector(&Type::f32(), (vec_len * 2u) as u64);
+                let vec_len = llvec_len(cls.tailn(i + 1u)) * 2u;
+                let vec_ty = Type::vector(&Type::f32(), vec_len as u64);
                 tys.push(vec_ty);
                 i += vec_len;
                 loop;

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

@@ -62,9 +62,9 @@ pub struct FnData {
 pub struct MethodData {
     llfn: ValueRef,
     llself: ValueRef,
-    temp_cleanup: Option<ValueRef>,
     self_ty: ty::t,
     self_mode: ty::SelfMode,
+    explicit_self: ast::explicit_self_
 }
 
 pub enum CalleeData {
@@ -615,7 +615,10 @@ pub fn trans_call_inner(in_cx: block,
                 }
                 Method(d) => {
                     // Weird but true: we pass self in the *environment* slot!
-                    (d.llfn, d.llself)
+                    let llself = PointerCast(bcx,
+                                             d.llself,
+                                             Type::opaque_box(ccx).ptr_to());
+                    (d.llfn, llself)
                 }
                 Closure(d) => {
                     // Closures are represented as (llfn, llclosure) pair:
@@ -644,12 +647,11 @@ pub fn trans_call_inner(in_cx: block,
 
 
         // Now that the arguments have finished evaluating, we need to revoke
-        // the cleanup for the self argument
+        // the cleanup for the self argument, if it exists
         match callee.data {
-            Method(d) => {
-                for d.temp_cleanup.iter().advance |&v| {
-                    revoke_clean(bcx, v);
-                }
+            Method(d) if d.self_mode == ty::ByCopy ||
+                         d.explicit_self == ast::sty_value => {
+                revoke_clean(bcx, d.llself);
             }
             _ => {}
         }
@@ -770,6 +772,7 @@ pub fn trans_args(cx: block,
                 trans_arg_expr(bcx,
                                arg_tys[i],
                                ty::ByCopy,
+                               ast::sty_static,
                                *arg_expr,
                                &mut temp_cleanups,
                                if i == last { ret_flag } else { None },
@@ -803,16 +806,18 @@ pub enum AutorefArg {
 pub fn trans_arg_expr(bcx: block,
                       formal_arg_ty: ty::t,
                       self_mode: ty::SelfMode,
+                      ex_self: ast::explicit_self_,
                       arg_expr: @ast::expr,
                       temp_cleanups: &mut ~[ValueRef],
                       ret_flag: Option<ValueRef>,
                       autoref_arg: AutorefArg) -> Result {
     let _icx = push_ctxt("trans_arg_expr");
     let ccx = bcx.ccx();
 
-    debug!("trans_arg_expr(formal_arg_ty=(%s), self_mode=%?, arg_expr=%s, \
+    debug!("trans_arg_expr(formal_arg_ty=(%s), explicit_self=%? self_mode=%?, arg_expr=%s, \
             ret_flag=%?)",
            formal_arg_ty.repr(bcx.tcx()),
+           ex_self,
            self_mode,
            arg_expr.repr(bcx.tcx()),
            ret_flag.map(|v| bcx.val_to_str(*v)));
@@ -872,15 +877,9 @@ pub fn trans_arg_expr(bcx: block,
                 val = arg_datum.to_ref_llval(bcx);
             }
             DontAutorefArg => {
-                match self_mode {
-                    ty::ByRef => {
-                        // This assertion should really be valid, but because
-                        // the explicit self code currently passes by-ref, it
-                        // does not hold.
-                        //
-                        //assert !bcx.ccx().maps.moves_map.contains_key(
-                        //    &arg_expr.id);
-                        debug!("by ref arg with type %s, storing to scratch",
+                match (self_mode, ex_self) {
+                    (ty::ByRef, ast::sty_value) => {
+                        debug!("by value self with type %s, storing to scratch",
                                bcx.ty_to_str(arg_datum.ty));
                         let scratch = scratch_datum(bcx, arg_datum.ty, false);
 
@@ -897,7 +896,18 @@ pub fn trans_arg_expr(bcx: block,
 
                         val = scratch.to_ref_llval(bcx);
                     }
-                    ty::ByCopy => {
+                    (ty::ByRef, _) => {
+                        // This assertion should really be valid, but because
+                        // the explicit self code currently passes by-ref, it
+                        // does not hold.
+                        //
+                        //assert !bcx.ccx().maps.moves_map.contains_key(
+                        //    &arg_expr.id);
+                        debug!("by ref arg with type %s",
+                               bcx.ty_to_str(arg_datum.ty));
+                        val = arg_datum.to_ref_llval(bcx);
+                    }
+                    (ty::ByCopy, _) => {
                         if ty::type_needs_drop(bcx.tcx(), arg_datum.ty) ||
                                 arg_datum.appropriate_mode().is_by_ref() {
                             debug!("by copy arg with type %s, storing to scratch",
@@ -920,7 +930,7 @@ pub fn trans_arg_expr(bcx: block,
                                 ByRef(_) => val = scratch.val,
                             }
                         } else {
-                            debug!("by copy arg with type %s", bcx.ty_to_str(arg_datum.ty));
+                            debug!("by copy arg with type %s");
                             match arg_datum.mode {
                                 ByRef(_) => val = Load(bcx, arg_datum.val),
                                 ByValue => val = arg_datum.val,
@@ -934,6 +944,10 @@ pub fn trans_arg_expr(bcx: block,
         if formal_arg_ty != arg_datum.ty {
             // this could happen due to e.g. subtyping
             let llformal_arg_ty = type_of::type_of_explicit_arg(ccx, &formal_arg_ty);
+            let llformal_arg_ty = match self_mode {
+                ty::ByRef => llformal_arg_ty.ptr_to(),
+                ty::ByCopy => llformal_arg_ty,
+            };
             debug!("casting actual type (%s) to match formal (%s)",
                    bcx.val_to_str(val), bcx.llty_str(llformal_arg_ty));
             val = PointerCast(bcx, val, llformal_arg_ty);

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

@@ -125,7 +125,7 @@ pub type ExternMap = HashMap<@str, ValueRef>;
 pub struct ValSelfData {
     v: ValueRef,
     t: ty::t,
-    is_copy: bool,
+    is_owned: bool
 }
 
 // Here `self_ty` is the real type of the self parameter to this method. It

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

@@ -425,7 +425,12 @@ pub fn trans_struct_drop_flag(bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast:
         // just consist of the environment (self)
         assert_eq!(params.len(), 1);
 
-        let self_arg = PointerCast(bcx, v0, params[0]);
+        // Take a reference to the class (because it's using the Drop trait),
+        // do so now.
+        let llval = alloca(bcx, val_ty(v0));
+        Store(bcx, v0, llval);
+
+        let self_arg = PointerCast(bcx, llval, params[0]);
         let args = ~[self_arg];
 
         Call(bcx, dtor_addr, args);
@@ -460,7 +465,12 @@ pub fn trans_struct_drop(mut bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast::
     // just consist of the environment (self)
     assert_eq!(params.len(), 1);
 
-    let self_arg = PointerCast(bcx, v0, params[0]);
+    // Take a reference to the class (because it's using the Drop trait),
+    // do so now.
+    let llval = alloca(bcx, val_ty(v0));
+    Store(bcx, v0, llval);
+
+    let self_arg = PointerCast(bcx, llval, params[0]);
     let args = ~[self_arg];
 
     Call(bcx, dtor_addr, args);

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

@@ -12,7 +12,7 @@ use core::prelude::*;
 
 use metadata::csearch;
 use middle::astencode;
-use middle::trans::base::{push_ctxt, impl_self, no_self};
+use middle::trans::base::{push_ctxt,impl_owned_self, impl_self, no_self};
 use middle::trans::base::{trans_item, get_item_val, trans_fn};
 use middle::trans::common::*;
 use middle::ty;
@@ -114,8 +114,8 @@ pub fn maybe_instantiate_inline(ccx: @mut CrateContext, fn_id: ast::def_id,
                       debug!("calling inline trans_fn with self_ty %s",
                              ty_to_str(ccx.tcx, self_ty));
                       match mth.explicit_self.node {
-                          ast::sty_value => impl_self(self_ty, ty::ByRef),
-                          _ => impl_self(self_ty, ty::ByCopy),
+                          ast::sty_value => impl_owned_self(self_ty),
+                          _ => impl_self(self_ty),
                       }
                   }
               };