---

yaml
---
r: 96149
b: refs/heads/dist-snap
c: d0872eb
h: refs/heads/master
i:
  96147: 3dfe2d6
v: v3

Author: michaelwoerister

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 3d569df41de221ce5b0ffd385caaa9fd6d5fb2ff
+refs/heads/dist-snap: d0872eb69272b5e74678b3bc095cc3082f46a5c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/middle/reachable.rs

@@ -260,132 +260,103 @@ impl ReachableContext {
                 continue
             }
             scanned.insert(search_item);
-            match self.tcx.items.find(&search_item) {
-                Some(item) => self.propagate_node(item, search_item,
-                                                  &mut visitor),
-                None if search_item == ast::CRATE_NODE_ID => {}
-                None => {
-                    self.tcx.sess.bug(format!("found unmapped ID in worklist: \
-                                               {}",
-                                              search_item))
-                }
-            }
-        }
-    }
+            self.reachable_symbols.insert(search_item);
 
-    fn propagate_node(&self, node: &ast_map::ast_node,
-                      search_item: ast::NodeId,
-                      visitor: &mut MarkSymbolVisitor) {
-        if !*self.tcx.sess.building_library {
-            // If we are building an executable, then there's no need to flag
-            // anything as external except for `extern fn` types. These
-            // functions may still participate in some form of native interface,
-            // but all other rust-only interfaces can be private (they will not
-            // participate in linkage after this product is produced)
-            match *node {
-                ast_map::node_item(item, _) => {
+            // Find the AST block corresponding to the item and visit it,
+            // marking all path expressions that resolve to something
+            // interesting.
+            match self.tcx.items.find(&search_item) {
+                Some(&ast_map::node_item(item, _)) => {
                     match item.node {
-                        ast::item_fn(_, ast::extern_fn, _, _, _) => {
-                            self.reachable_symbols.insert(search_item);
+                        ast::item_fn(_, _, _, _, ref search_block) => {
+                            if item_might_be_inlined(item) {
+                                visit::walk_block(&mut visitor, search_block, ())
+                            }
                         }
-                        _ => {}
-                    }
-                }
-                _ => {}
-            }
-        } else {
-            // If we are building a library, then reachable symbols will
-            // continue to participate in linkage after this product is
-            // produced. In this case, we traverse the ast node, recursing on
-            // all reachable nodes from this one.
-            self.reachable_symbols.insert(search_item);
-        }
 
-        match *node {
-            ast_map::node_item(item, _) => {
-                match item.node {
-                    ast::item_fn(_, _, _, _, ref search_block) => {
-                        if item_might_be_inlined(item) {
-                            visit::walk_block(visitor, search_block, ())
-                        }
-                    }
-
-                    // Implementations of exported structs/enums need to get
-                    // added to the worklist (as all their methods should be
-                    // accessible)
-                    ast::item_struct(*) | ast::item_enum(*) => {
-                        let def = local_def(item.id);
-                        let impls = match self.tcx.inherent_impls.find(&def) {
-                            Some(&impls) => impls,
-                            None => return
-                        };
-                        for imp in impls.iter() {
-                            if is_local(imp.did) {
-                                self.worklist.push(imp.did.node);
+                        // Implementations of exported structs/enums need to get
+                        // added to the worklist (as all their methods should be
+                        // accessible)
+                        ast::item_struct(*) | ast::item_enum(*) => {
+                            let def = local_def(item.id);
+                            let impls = match self.tcx.inherent_impls.find(&def) {
+                                Some(&impls) => impls,
+                                None => continue
+                            };
+                            for imp in impls.iter() {
+                                if is_local(imp.did) {
+                                    self.worklist.push(imp.did.node);
+                                }
                             }
                         }
-                    }
 
-                    // Propagate through this impl
-                    ast::item_impl(_, _, _, ref methods) => {
-                        for method in methods.iter() {
-                            self.worklist.push(method.id);
+                        // Propagate through this impl
+                        ast::item_impl(_, _, _, ref methods) => {
+                            for method in methods.iter() {
+                                self.worklist.push(method.id);
+                            }
                         }
-                    }
 
-                    // Default methods of exported traits need to all be
-                    // accessible.
-                    ast::item_trait(_, _, ref methods) => {
-                        for method in methods.iter() {
-                            match *method {
-                                ast::required(*) => {}
-                                ast::provided(ref method) => {
-                                    self.worklist.push(method.id);
+                        // Default methods of exported traits need to all be
+                        // accessible.
+                        ast::item_trait(_, _, ref methods) => {
+                            for method in methods.iter() {
+                                match *method {
+                                    ast::required(*) => {}
+                                    ast::provided(ref method) => {
+                                        self.worklist.push(method.id);
+                                    }
                                 }
                             }
                         }
-                    }
 
-                    // These are normal, nothing reachable about these
-                    // inherently and their children are already in the
-                    // worklist
-                    ast::item_static(*) | ast::item_ty(*) |
-                        ast::item_mod(*) | ast::item_foreign_mod(*) => {}
+                        // These are normal, nothing reachable about these
+                        // inherently and their children are already in the
+                        // worklist
+                        ast::item_static(*) | ast::item_ty(*) |
+                            ast::item_mod(*) | ast::item_foreign_mod(*) => {}
 
-                    _ => {
-                        self.tcx.sess.span_bug(item.span,
-                                               "found non-function item \
-                                                in worklist?!")
+                        _ => {
+                            self.tcx.sess.span_bug(item.span,
+                                                   "found non-function item \
+                                                    in worklist?!")
+                        }
                     }
                 }
-            }
-            ast_map::node_trait_method(trait_method, _, _) => {
-                match *trait_method {
-                    ast::required(*) => {
-                        // Keep going, nothing to get exported
+                Some(&ast_map::node_trait_method(trait_method, _, _)) => {
+                    match *trait_method {
+                        ast::required(*) => {
+                            // Keep going, nothing to get exported
+                        }
+                        ast::provided(ref method) => {
+                            visit::walk_block(&mut visitor, &method.body, ())
+                        }
                     }
-                    ast::provided(ref method) => {
-                        visit::walk_block(visitor, &method.body, ())
+                }
+                Some(&ast_map::node_method(method, did, _)) => {
+                    if method_might_be_inlined(self.tcx, method, did) {
+                        visit::walk_block(&mut visitor, &method.body, ())
                     }
                 }
-            }
-            ast_map::node_method(method, did, _) => {
-                if method_might_be_inlined(self.tcx, method, did) {
-                    visit::walk_block(visitor, &method.body, ())
+                // Nothing to recurse on for these
+                Some(&ast_map::node_foreign_item(*)) |
+                Some(&ast_map::node_variant(*)) |
+                Some(&ast_map::node_struct_ctor(*)) => {}
+                Some(_) => {
+                    let ident_interner = token::get_ident_interner();
+                    let desc = ast_map::node_id_to_str(self.tcx.items,
+                                                       search_item,
+                                                       ident_interner);
+                    self.tcx.sess.bug(format!("found unexpected thingy in \
+                                               worklist: {}",
+                                               desc))
+                }
+                None if search_item == ast::CRATE_NODE_ID => {}
+                None => {
+                    self.tcx.sess.bug(format!("found unmapped ID in worklist: \
+                                               {}",
+                                              search_item))
                 }
-            }
-            // Nothing to recurse on for these
-            ast_map::node_foreign_item(*) |
-            ast_map::node_variant(*) |
-            ast_map::node_struct_ctor(*) => {}
-            _ => {
-                let ident_interner = token::get_ident_interner();
-                let desc = ast_map::node_id_to_str(self.tcx.items,
-                                                   search_item,
-                                                   ident_interner);
-                self.tcx.sess.bug(format!("found unexpected thingy in \
-                                           worklist: {}",
-                                           desc))
             }
         }
     }

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -2294,7 +2294,7 @@ fn finish_register_fn(ccx: @mut CrateContext, sp: Span, sym: ~str, node_id: ast:
                       llfn: ValueRef) {
     ccx.item_symbols.insert(node_id, sym);
 
-    if !ccx.reachable.contains(&node_id) {
+    if !*ccx.sess.building_library {
         lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
     }
 
@@ -2504,7 +2504,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                                     llvm::LLVMAddGlobal(ccx.llmod, llty, buf)
                                 };
 
-                                if !ccx.reachable.contains(&id) {
+                                if !*ccx.sess.building_library {
                                     lib::llvm::SetLinkage(g, lib::llvm::InternalLinkage);
                                 }
 

branches/dist-snap/src/librustc/middle/trans/controlflow.rs

@@ -14,6 +14,7 @@ use middle::trans::base::*;
 use middle::trans::build::*;
 use middle::trans::callee;
 use middle::trans::common::*;
+use middle::trans::debuginfo;
 use middle::trans::expr;
 use middle::ty;
 use util::common::indenter;
@@ -75,6 +76,7 @@ pub fn trans_if(bcx: @mut Block,
             // if true { .. } [else { .. }]
             return do with_scope(bcx, thn.info(), "if_true_then") |bcx| {
                 let bcx_out = trans_block(bcx, thn, dest);
+                debuginfo::clear_source_location(bcx.fcx);
                 trans_block_cleanups(bcx_out, block_cleanups(bcx))
             }
         } else {
@@ -86,6 +88,7 @@ pub fn trans_if(bcx: @mut Block,
                 Some(elexpr) => {
                     return do with_scope(bcx, elexpr.info(), "if_false_then") |bcx| {
                         let bcx_out = trans_if_else(bcx, elexpr, dest);
+                        debuginfo::clear_source_location(bcx.fcx);
                         trans_block_cleanups(bcx_out, block_cleanups(bcx))
                     }
                 }
@@ -98,6 +101,8 @@ pub fn trans_if(bcx: @mut Block,
     let then_bcx_in = scope_block(bcx, thn.info(), "then");
 
     let then_bcx_out = trans_block(then_bcx_in, thn, dest);
+
+    debuginfo::clear_source_location(bcx.fcx);
     let then_bcx_out = trans_block_cleanups(then_bcx_out,
                                             block_cleanups(then_bcx_in));
 
@@ -122,6 +127,9 @@ pub fn trans_if(bcx: @mut Block,
     debug!("then_bcx_in={}, else_bcx_in={}",
            then_bcx_in.to_str(), else_bcx_in.to_str());
 
+    // Clear the source location because it is still set to whatever has been translated
+    // right before.
+    debuginfo::clear_source_location(else_bcx_in.fcx);
     CondBr(bcx, cond_val, then_bcx_in.llbb, else_bcx_in.llbb);
     return next_bcx;
 
@@ -139,6 +147,7 @@ pub fn trans_if(bcx: @mut Block,
             // would be nice to have a constraint on ifs
             _ => else_bcx_in.tcx().sess.bug("strange alternative in if")
         };
+        debuginfo::clear_source_location(else_bcx_in.fcx);
         trans_block_cleanups(else_bcx_out, block_cleanups(else_bcx_in))
     }
 }

branches/dist-snap/src/librustc/middle/trans/debuginfo.rs

@@ -509,6 +509,17 @@ pub fn set_source_location(fcx: &FunctionContext,
     }
 }
 
+/// Clears the current debug location.
+///
+/// Instructions generated hereafter won't be assigned a source location.
+pub fn clear_source_location(fcx: &FunctionContext) {
+    if fn_should_be_ignored(fcx) {
+        return;
+    }
+
+    set_debug_location(fcx.ccx, UnknownLocation);
+}
+
 /// Enables emitting source locations for the given functions.
 ///
 /// Since we don't want source locations to be emitted for the function prelude, they are disabled