---

yaml
---
r: 81924
b: refs/heads/master
c: 2835df2
h: refs/heads/master
v: v3

Author: pnkfelix

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c3e4e068416438e91e3e9809ee8553a764d8e26e
+refs/heads/master: 2835df2db65b1c03f3f21f553b8f31db0fb1b6c0
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/Makefile.in

@@ -608,6 +608,10 @@ config.stamp: $(S)configure $(S)Makefile.in $(S)src/snapshots.txt
 # Primary-target makefiles
 ######################################################################
 
+# Issue #9531: If you change the order of any of the following (or add
+# new definitions), make sure definitions always precede their uses,
+# especially for the dependency lists of recipes.
+
 include $(CFG_SRC_DIR)mk/target.mk
 include $(CFG_SRC_DIR)mk/host.mk
 include $(CFG_SRC_DIR)mk/stage0.mk

trunk/mk/stage0.mk

@@ -6,8 +6,6 @@ $(HBIN0_H_$(CFG_BUILD_TRIPLE))/:
 $(HLIB0_H_$(CFG_BUILD_TRIPLE))/:
 	mkdir -p $@
 
-SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD_TRIPLE))/rustc$(X_$(CFG_BUILD_TRIPLE))
-
 $(SNAPSHOT_RUSTC_POST_CLEANUP):						\
 		$(S)src/snapshots.txt					\
 		$(S)src/etc/get-snapshot.py $(MKFILE_DEPS)		\

trunk/mk/target.mk

@@ -36,6 +36,8 @@ WFLAGS_ST2 = -D warnings
 # had its chance to clean it out; otherwise the other products will be
 # inadvertantly included in the clean out.
 
+SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD_TRIPLE))/rustc$(X_$(CFG_BUILD_TRIPLE))
+
 define TARGET_STAGE_N
 
 $$(TLIB$(1)_T_$(2)_H_$(3))/libmorestack.a: \

trunk/src/etc/monodebug.pl

@@ -0,0 +1,79 @@
+#!/usr/bin/perl
+
+#
+# This is a tool that helps with debugging incorrect monomorphic instance collapse.
+#
+# To use:
+#    $ RUST_LOG=rustc::middle::trans::monomorphize rustc ARGS 2>&1 >log.txt
+#    $ ./monodebug.pl log.txt
+#
+# This will show all generics that got collapsed. You can inspect this list to find the instances
+# that were mistakenly combined into one. Fixes will (most likely) be applied to type_use.rs.
+#
+# Questions about this tool go to pcwalton.
+#
+
+use strict;
+use warnings;
+use Data::Dumper qw(Dumper);
+use Text::Balanced qw(extract_bracketed);
+
+my %funcs;
+while (<>) {
+    chomp;
+    /^rust: ~"monomorphic_fn\((.*)"$/ or next;
+    my $text = $1;
+    $text =~ /fn_id=(\{ crate: \d+, node: \d+ \} \([^)]+\)), real_substs=(.*?), substs=(.*?), hash_id = \@\{ (.*) \}$/ or next;
+    my ($fn_id, $real_substs, $substs, $hash_id) = ($1, $2, $3, $4);
+
+    #print "$hash_id\n";
+    $hash_id =~ /^def: { crate: \d+, node: \d+ }, params: ~\[ (.*) \], impl_did_opt: (?:None|Some\({ crate: \d+, node: \d+ }\))$/ or next;
+    my $params = $1;
+
+    my @real_substs;
+    @real_substs = $real_substs =~ /\\"(.*?)\\"/g;
+
+    my @mono_params;
+    while (1) {
+        $params =~ s/^, //;
+        if ($params =~ s/^mono_precise//) {
+            extract_bracketed($params, '()');
+            push @mono_params, 'precise';
+            next;
+        }
+        if ($params =~ s/^mono_repr//) {
+            my $sub = extract_bracketed($params, '()');
+            push @mono_params, "repr($sub)";
+            next;
+        }
+        if ($params =~ s/^mono_any//) {
+            push @mono_params, "any";
+            next;
+        }
+        last;
+    }
+
+    my @key_params;
+    for (my $i = 0; $i < @mono_params; ++$i) {
+        if ($mono_params[$i] eq 'precise') {
+            push @key_params, 'precise(' . $real_substs[$i] . ')';
+        } else {
+            push @key_params, $mono_params[$i];
+        }
+    }
+
+    my $key = "$fn_id with " . (join ', ', @key_params);
+    $funcs{$key}{$real_substs} = 1;
+}
+
+while (my ($key, $substs) = each %funcs) {
+    my @params = keys %$substs;
+    next if @params == 1;
+
+    print "$key\n";
+    print(('-' x (length $key)), $/);
+    for my $param (@params) {
+        print "$param\n";
+    }
+    print "\n";
+}

trunk/src/etc/zsh/_rust

@@ -71,6 +71,7 @@ _rustc_opts_debug=(
     'count-type-sizes:count the sizes of aggregate types'
     'meta-stats:gather metadata statistics'
     'no-opt:do not optimize, even if -O is passed'
+    'no-monomorphic-collapse:do not collapse template instantiations'
     'print-link-args:Print the arguments passed to the linker'
     'gc:Garbage collect shared data (experimental)'
     'jit:Execute using JIT (experimental)'

trunk/src/librustc/driver/driver.rs

@@ -748,6 +748,13 @@ pub fn build_session_options(binary: @str,
     let debuginfo = debugging_opts & session::debug_info != 0 ||
         extra_debuginfo;
 
+    // If debugging info is generated, do not collapse monomorphized function instances.
+    // Functions with equivalent llvm code still need separate debugging descriptions because names
+    // might differ.
+    if debuginfo {
+        debugging_opts |= session::no_monomorphic_collapse;
+    }
+
     let statik = debugging_opts & session::statik != 0;
 
     let addl_lib_search_paths = matches.opt_strs("L").map(|s| Path(*s));

trunk/src/librustc/driver/session.rs

@@ -67,19 +67,20 @@ pub static debug_llvm:              uint = 1 << 13;
 pub static count_type_sizes:        uint = 1 << 14;
 pub static meta_stats:              uint = 1 << 15;
 pub static no_opt:                  uint = 1 << 16;
-pub static gc:                      uint = 1 << 17;
-pub static jit:                     uint = 1 << 18;
-pub static debug_info:              uint = 1 << 19;
-pub static extra_debug_info:        uint = 1 << 20;
-pub static statik:                  uint = 1 << 21;
-pub static print_link_args:         uint = 1 << 22;
-pub static no_debug_borrows:        uint = 1 << 23;
-pub static lint_llvm:               uint = 1 << 24;
-pub static once_fns:                uint = 1 << 25;
-pub static print_llvm_passes:       uint = 1 << 26;
-pub static no_vectorize_loops:      uint = 1 << 27;
-pub static no_vectorize_slp:        uint = 1 << 28;
-pub static no_prepopulate_passes:   uint = 1 << 29;
+pub static no_monomorphic_collapse: uint = 1 << 17;
+pub static gc:                      uint = 1 << 18;
+pub static jit:                     uint = 1 << 19;
+pub static debug_info:              uint = 1 << 20;
+pub static extra_debug_info:        uint = 1 << 21;
+pub static statik:                  uint = 1 << 22;
+pub static print_link_args:         uint = 1 << 23;
+pub static no_debug_borrows:        uint = 1 << 24;
+pub static lint_llvm:               uint = 1 << 25;
+pub static once_fns:                uint = 1 << 26;
+pub static print_llvm_passes:       uint = 1 << 27;
+pub static no_vectorize_loops:      uint = 1 << 28;
+pub static no_vectorize_slp:        uint = 1 << 29;
+pub static no_prepopulate_passes:   uint = 1 << 30;
 
 pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
     ~[(~"verbose", ~"in general, enable more debug printouts", verbose),
@@ -105,6 +106,8 @@ pub 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),
      (~"print-link-args", ~"Print the arguments passed to the linker", print_link_args),
      (~"gc", ~"Garbage collect shared data (experimental)", gc),
      (~"jit", ~"Execute using JIT (experimental)", jit),
@@ -323,6 +326,9 @@ impl Session_ {
     pub fn borrowck_note_loan(&self) -> bool {
         self.debugging_opt(borrowck_note_loan)
     }
+    pub fn no_monomorphic_collapse(&self) -> bool {
+        self.debugging_opt(no_monomorphic_collapse)
+    }
     pub fn debug_borrows(&self) -> bool {
         self.opts.optimize == No && !self.debugging_opt(no_debug_borrows)
     }

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

@@ -22,6 +22,7 @@ use middle::trans::adt;
 use middle::trans::base;
 use middle::trans::builder::Builder;
 use middle::trans::debuginfo;
+use middle::trans::type_use;
 use middle::trans::common::{C_i32, C_null};
 use middle::ty;
 
@@ -72,6 +73,8 @@ pub struct CrateContext {
      // Cache instances of monomorphized functions
      monomorphized: HashMap<mono_id, ValueRef>,
      monomorphizing: HashMap<ast::DefId, uint>,
+     // Cache computed type parameter uses (see type_use.rs)
+     type_use_cache: HashMap<ast::DefId, @~[type_use::type_uses]>,
      // Cache generated vtables
      vtables: HashMap<(ty::t, mono_id), ValueRef>,
      // Cache of constant strings,
@@ -201,6 +204,7 @@ impl CrateContext {
                   non_inlineable_statics: HashSet::new(),
                   monomorphized: HashMap::new(),
                   monomorphizing: HashMap::new(),
+                  type_use_cache: HashMap::new(),
                   vtables: HashMap::new(),
                   const_cstr_cache: HashMap::new(),
                   const_globals: HashMap::new(),

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

@@ -520,7 +520,8 @@ pub fn vtable_id(ccx: @mut CrateContext,
             monomorphize::make_mono_id(
                 ccx,
                 impl_id,
-                &psubsts)
+                &psubsts,
+                None)
         }
 
         // can't this be checked at the callee?

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

@@ -38,6 +38,7 @@ pub mod foreign;
 pub mod intrinsic;
 pub mod reflect;
 pub mod debuginfo;
+pub mod type_use;
 pub mod machine;
 pub mod adt;
 pub mod asm;

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

@@ -18,11 +18,15 @@ use middle::trans::base::{trans_fn, decl_internal_rust_fn};
 use middle::trans::base::{get_item_val, no_self};
 use middle::trans::base;
 use middle::trans::common::*;
+use middle::trans::datum;
+use middle::trans::machine;
 use middle::trans::meth;
+use middle::trans::type_of;
+use middle::trans::type_use;
 use middle::trans::intrinsic;
 use middle::ty;
 use middle::typeck;
-use util::ppaux::Repr;
+use util::ppaux::{Repr,ty_to_str};
 
 use syntax::ast;
 use syntax::ast_map;
@@ -61,8 +65,10 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
 
     for s in real_substs.tps.iter() { assert!(!ty::type_has_params(*s)); }
     for s in psubsts.tys.iter() { assert!(!ty::type_has_params(*s)); }
+    let param_uses = type_use::type_uses_for(ccx, fn_id, psubsts.tys.len());
 
-    let hash_id = make_mono_id(ccx, fn_id, &*psubsts);
+
+    let hash_id = make_mono_id(ccx, fn_id, &*psubsts, Some(param_uses));
     if hash_id.params.iter().any(
                 |p| match *p { mono_precise(_, _) => false, _ => true }) {
         must_cast = true;
@@ -296,7 +302,8 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
 
 pub fn make_mono_id(ccx: @mut CrateContext,
                     item: ast::DefId,
-                    substs: &param_substs) -> mono_id {
+                    substs: &param_substs,
+                    param_uses: Option<@~[type_use::type_uses]>) -> mono_id {
     // FIXME (possibly #5801): Need a lot of type hints to get
     // .collect() to work.
     let substs_iter = substs.self_ty.iter().chain(substs.tys.iter());
@@ -314,9 +321,59 @@ pub fn make_mono_id(ccx: @mut CrateContext,
     };
 
 
-    let param_ids = precise_param_ids.iter().map(|x| {
-        let (a, b) = *x;
-        mono_precise(a, b)
-    }).collect();
+    let param_ids = match param_uses {
+      Some(ref uses) => {
+        // param_uses doesn't include a use for the self type.
+        // We just say it is fully used.
+        let self_use =
+            substs.self_ty.map(|_| type_use::use_repr|type_use::use_tydesc);
+        let uses_iter = self_use.iter().chain(uses.iter());
+
+        precise_param_ids.iter().zip(uses_iter).map(|(id, uses)| {
+            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 == 0 {
+                            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 = machine::llalign_of_min(ccx, llty);
+                            let mode = datum::appropriate_mode(ccx.tcx, subst);
+                            let data_class = mono_data_classify(subst);
+
+                            debug!("make_mono_id: type %s -> size %u align %u mode %? class %?",
+                                  ty_to_str(ccx.tcx, subst),
+                                  size, align, mode, data_class);
+
+                            // Special value for nil to prevent problems
+                            // with undef return pointers.
+                            if size <= 8u && ty::type_is_nil(subst) {
+                                mono_repr(0u, 0u, data_class, mode)
+                            } else {
+                                mono_repr(size, align, data_class, mode)
+                            }
+                        } else {
+                            mono_precise(subst, None)
+                        }
+                    }
+                }
+            }
+        }).collect()
+      }
+      None => {
+          precise_param_ids.iter().map(|x| {
+              let (a, b) = *x;
+              mono_precise(a, b)
+          }).collect()
+      }
+    };
     @mono_id_ {def: item, params: param_ids}
 }