---

yaml
---
r: 39226
b: refs/heads/incoming
c: 4fc03ba
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
-refs/heads/incoming: aa3aa3b1b2b6d648af35122905d4958ad72377fb
+refs/heads/incoming: 4fc03bac654e6956024b52f2216c1803bb6ce7a6
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/librustc/driver/session.rs

@@ -65,6 +65,7 @@ const debug_llvm: uint = 1 << 13;
 const count_type_sizes: uint = 1 << 14;
 const meta_stats: uint = 1 << 15;
 const no_opt: uint = 1 << 16;
+const no_monomorphic_collapse: uint = 1 << 17;
 
 fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
     ~[(~"verbose", ~"in general, enable more debug printouts", verbose),
@@ -90,6 +91,8 @@ fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
       count_type_sizes),
      (~"meta-stats", ~"gather metadata statistics", meta_stats),
      (~"no-opt", ~"do not optimize, even if -O is passed", no_opt),
+     (~"no-monomorphic-collapse", ~"do not collapse template instantiations",
+      no_monomorphic_collapse),
     ]
 }
 
@@ -242,6 +245,9 @@ impl Session {
     fn borrowck_stats() -> bool { self.debugging_opt(borrowck_stats) }
     fn borrowck_note_pure() -> bool { self.debugging_opt(borrowck_note_pure) }
     fn borrowck_note_loan() -> bool { self.debugging_opt(borrowck_note_loan) }
+    fn no_monomorphic_collapse() -> bool {
+        self.debugging_opt(no_monomorphic_collapse)
+    }
 
     fn str_of(id: ast::ident) -> ~str {
         *self.parse_sess.interner.get(id)

branches/incoming/src/librustc/middle/trans/monomorphize.rs

@@ -320,37 +320,43 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t],
     let param_ids = match param_uses {
       Some(uses) => {
         vec::map2(precise_param_ids, uses, |id, uses| {
-            match *id {
-                (a, b@Some(_)) => mono_precise(a, b),
-                (subst, None) => {
-                    if *uses == 0u {
-                        mono_any
-                    } else if *uses == type_use::use_repr &&
-                        !ty::type_needs_drop(ccx.tcx, subst)
-                    {
-                        let llty = type_of::type_of(ccx, subst);
-                        let size = machine::llbitsize_of_real(ccx, llty);
-                        let align = shape::llalign_of_pref(ccx, llty);
-                        let mode = datum::appropriate_mode(subst);
+            if ccx.sess.no_monomorphic_collapse() {
+                match *id {
+                    (a, b) => mono_precise(a, b)
+                }
+            } else {
+                match *id {
+                    (a, b@Some(_)) => mono_precise(a, b),
+                    (subst, None) => {
+                        if *uses == 0u {
+                            mono_any
+                        } else if *uses == type_use::use_repr &&
+                            !ty::type_needs_drop(ccx.tcx, subst)
+                        {
+                            let llty = type_of::type_of(ccx, subst);
+                            let size = machine::llbitsize_of_real(ccx, llty);
+                            let align = shape::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
-                        };
+                            // 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
+                            };
 
-                        // 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)
+                            // 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)
+                            } else {
+                                mono_repr(size, align, is_float, mode)
+                            }
                         } else {
-                            mono_repr(size, align, is_float, mode)
+                            mono_precise(subst, None)
                         }
-                    } else {
-                        mono_precise(subst, None)
                     }
                 }
             }