---

yaml
---
r: 55737
b: refs/heads/master
c: 70452e5
h: refs/heads/master
i:
  55735: f3f5ef5
v: v3

Author: jld

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0de3e7a23c0cd677a3f369ea1b65cd71f41dcda2
+refs/heads/master: 70452e5231d4101811b2ea6a2c4be4adc2b5460b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a

trunk/src/libcore/gc.rs

@@ -73,7 +73,6 @@ pub mod rustrt {
         pub unsafe fn rust_gc_metadata() -> *Word;
 
         pub unsafe fn rust_get_stack_segment() -> *StackSegment;
-        pub unsafe fn rust_get_c_stack() -> *StackSegment;
     }
 }
 

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

@@ -2007,6 +2007,11 @@ pub fn trans_enum_variant(ccx: @CrateContext,
     // XXX is there a better way to reconstruct the ty::t?
     let repr = adt::represent_type(ccx, enum_ty);
 
+    debug!("trans_enum_variant: name=%s tps=%s repr=%? enum_ty=%s",
+           unsafe { str::raw::from_c_str(llvm::LLVMGetValueName(llfndecl)) },
+           ~"[" + str::connect(ty_param_substs.map(|&t| ty_to_str(ccx.tcx, t)), ", ") + ~"]",
+           repr, ty_to_str(ccx.tcx, enum_ty));
+
     adt::trans_start_init(bcx, repr, fcx.llretptr.get(), disr);
     for vec::eachi(args) |i, va| {
         let lldestptr = adt::trans_field_ptr(bcx,

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

@@ -1311,10 +1311,35 @@ pub enum mono_param_id {
     mono_any,
     mono_repr(uint /* size */,
               uint /* align */,
-              bool /* is_float */,
+              MonoDataClass,
               datum::DatumMode),
 }
 
+#[deriving(Eq)]
+pub enum MonoDataClass {
+    MonoBits,    // Anything not treated differently from arbitrary integer data
+    MonoNonNull, // Non-null pointers (used for optional-pointer optimization)
+    // FIXME(#3547)---scalars and floats are
+    // treated differently in most ABIs.  But we
+    // should be doing something more detailed
+    // here.
+    MonoFloat
+}
+
+pub fn mono_data_classify(t: ty::t) -> MonoDataClass {
+    match ty::get(t).sty {
+        ty::ty_float(_) => MonoFloat,
+        ty::ty_rptr(*) | ty::ty_uniq(*) |
+        ty::ty_box(*) | ty::ty_opaque_box(*) |
+        ty::ty_estr(ty::vstore_uniq) | ty::ty_evec(_, ty::vstore_uniq) |
+        ty::ty_estr(ty::vstore_box) | ty::ty_evec(_, ty::vstore_box) |
+        ty::ty_bare_fn(*) => MonoNonNull,
+        // Is that everything?  Would closures or slices qualify?
+        _ => MonoBits
+    }
+}
+
+
 #[deriving(Eq)]
 pub struct mono_id_ {
     def: ast::def_id,
@@ -1338,6 +1363,12 @@ impl to_bytes::IterBytes for mono_param_id {
     }
 }
 
+impl to_bytes::IterBytes for MonoDataClass {
+    fn iter_bytes(&self, lsb0: bool, f:to_bytes::Cb) {
+        (*self as u8).iter_bytes(lsb0, f)
+    }
+}
+
 impl to_bytes::IterBytes for mono_id_ {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f);

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

@@ -395,22 +395,14 @@ pub fn make_mono_id(ccx: @CrateContext,
                             let size = machine::llbitsize_of_real(ccx, llty);
                             let align = machine::llalign_of_pref(ccx, llty);
                             let mode = datum::appropriate_mode(subst);
-
-                            // FIXME(#3547)---scalars and floats are
-                            // treated differently in most ABIs.  But we
-                            // should be doing something more detailed
-                            // here.
-                            let is_float = match ty::get(subst).sty {
-                                ty::ty_float(_) => true,
-                                _ => false
-                            };
+                            let data_class = mono_data_classify(subst);
 
                             // Special value for nil to prevent problems
                             // with undef return pointers.
                             if size <= 8u && ty::type_is_nil(subst) {
-                                mono_repr(0u, 0u, is_float, mode)
+                                mono_repr(0u, 0u, data_class, mode)
                             } else {
-                                mono_repr(size, align, is_float, mode)
+                                mono_repr(size, align, data_class, mode)
                             }
                         } else {
                             mono_precise(subst, None)

trunk/src/libstd/num/rational.rs

@@ -51,7 +51,7 @@ impl<T: Copy + Num + Ord>
     #[inline(always)]
     pub fn new(numer: T, denom: T) -> Ratio<T> {
         if denom == Zero::zero() {
-            fail!(~"denominator == 0");
+            fail!(~"quotient of 0");
         }
         let mut ret = Ratio::new_raw(numer, denom);
         ret.reduce();

trunk/src/llvm

@@ -1 +1 @@
-Subproject commit 56dd407f4f97a01b8df6554c569170d2fc276fcb
+Subproject commit 2e9f0d21fe321849a4759a01fc28eae82ef196d6

trunk/src/rt/rust_builtin.cpp

@@ -549,11 +549,6 @@ rust_get_stack_segment() {
     return rust_get_current_task()->stk;
 }
 
-extern "C" CDECL stk_seg *
-rust_get_c_stack() {
-    return rust_get_current_task()->get_c_stack();
-}
-
 extern "C" CDECL void
 start_task(rust_task *target, fn_env_pair *f) {
     target->start(f->f, f->env, NULL);

trunk/src/rt/rust_task.h

@@ -374,7 +374,6 @@ rust_task : public kernel_owned<rust_task>
     void call_on_c_stack(void *args, void *fn_ptr);
     void call_on_rust_stack(void *args, void *fn_ptr);
     bool have_c_stack() { return c_stack != NULL; }
-    stk_seg *get_c_stack() { return c_stack; }
 
     rust_task_state get_state() { return state; }
     rust_cond *get_cond() { return cond; }

trunk/src/rt/rustrt.def.in

@@ -49,7 +49,6 @@ rust_task_is_unwinding
 rust_get_task
 rust_try_get_task
 rust_get_stack_segment
-rust_get_c_stack
 rust_log_str
 start_task
 vec_reserve_shared_actual