---

yaml
---
r: 147278
b: refs/heads/try2
c: c2c2c4d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d9525530482f12f9814f46148ba02d3d1ecebee5
+refs/heads/try2: c2c2c4d6f3dae07134858266b7f037ea110a6f82
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -2177,7 +2177,11 @@ Expressions are divided into two main categories: _lvalues_ and _rvalues_.
 Likewise within each expression, sub-expressions may occur in _lvalue context_ or _rvalue context_.
 The evaluation of an expression depends both on its own category and the context it occurs within.
 
-[Path](#path-expressions), [field](#field-expressions) and [index](#index-expressions) expressions are lvalues.
+An lvalue is an expression that represents a memory location. These
+expressions are [paths](#path-expressions) (which refer to local
+variables, function and method arguments, or static variables),
+dereferences (`*expr`), [indexing expressions](#index-expressions)
+(`expr[expr]`), and [field references](#field-expressions) (`expr.f`).
 All other expressions are rvalues.
 
 The left operand of an [assignment](#assignment-expressions),

branches/try2/src/libextra/lib.rs

@@ -20,22 +20,14 @@ Rust extras are part of the standard Rust distribution.
 
 */
 
-#[pkgid="extra#0.9-pre"];
-// NOTE: remove after the next snapshot
-#[link(name = "extra",
-       package_id = "extra",
-       vers = "0.9-pre",
-       uuid = "122bed0b-c19b-4b82-b0b7-7ae8aead7297",
-       url = "https://github.com/mozilla/rust/tree/master/src/libextra")];
-
-#[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
-      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
-      html_root_url = "http://static.rust-lang.org/doc/master")];
-
+#[pkgid = "extra#0.9-pre"];
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
+#[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+      html_root_url = "http://static.rust-lang.org/doc/master")];
 
 #[feature(macro_rules, globs, managed_boxes)];
 

branches/try2/src/librustc/front/test.rs

@@ -375,9 +375,8 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item {
 }
 
 fn is_extra(crate: &ast::Crate) -> bool {
-    let items = attr::find_linkage_metas(crate.attrs);
-    match attr::last_meta_item_value_str_by_name(items, "name") {
-        Some(s) if "extra" == s => true,
+    match attr::find_pkgid(crate.attrs) {
+        Some(ref s) if "extra" == s.name => true,
         _ => false
     }
 }

branches/try2/src/librustc/lib.rs

@@ -8,14 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[pkgid="rustc#0.9-pre"];
-// NOTE: remove after the next snapshot
-#[link(name = "rustc",
-       package_id = "rustc",
-       vers = "0.9-pre",
-       uuid = "0ce89b41-2f92-459e-bbc1-8f5fe32f16cf",
-       url = "https://github.com/mozilla/rust/tree/master/src/rustc")];
-
+#[pkgid = "rustc#0.9-pre"];
 #[comment = "The Rust compiler"];
 #[license = "MIT/ASL2"];
 #[crate_type = "dylib"];

branches/try2/src/librustc/middle/dead.rs

@@ -107,6 +107,8 @@ impl MarkSymbolVisitor {
                 match item.node {
                     ast::item_fn(..)
                     | ast::item_ty(..)
+                    | ast::item_enum(..)
+                    | ast::item_struct(..)
                     | ast::item_static(..) => {
                         visit::walk_item(self, item, ());
                     }

branches/try2/src/librustc/middle/trans/_match.rs

@@ -220,6 +220,7 @@ use util::common::indenter;
 use util::ppaux::{Repr, vec_map_to_str};
 
 use std::hashmap::HashMap;
+use std::ptr;
 use std::vec;
 use syntax::ast;
 use syntax::ast::Ident;
@@ -2046,7 +2047,10 @@ pub fn store_arg(mut bcx: @mut Block,
     // Debug information (the llvm.dbg.declare intrinsic to be precise) always expects to get an
     // alloca, which only is the case on the general path, so lets disable the optimized path when
     // debug info is enabled.
-    let fast_path = !bcx.ccx().sess.opts.extra_debuginfo && simple_identifier(pat).is_some();
+    let arg_is_alloca = unsafe { llvm::LLVMIsAAllocaInst(llval) != ptr::null() };
+
+    let fast_path = (arg_is_alloca || !bcx.ccx().sess.opts.extra_debuginfo)
+                    && simple_identifier(pat).is_some();
 
     if fast_path {
         // Optimized path for `x: T` case. This just adopts

branches/try2/src/librustc/middle/trans/base.rs

@@ -303,7 +303,7 @@ pub fn opaque_box_body(bcx: @mut Block,
     let _icx = push_ctxt("opaque_box_body");
     let ccx = bcx.ccx();
     let ty = type_of(ccx, body_t);
-    let ty = Type::box(ccx, &ty);
+    let ty = Type::smart_ptr(ccx, &ty);
     let boxptr = PointerCast(bcx, boxptr, ty.ptr_to());
     GEPi(bcx, boxptr, [0u, abi::box_field_body])
 }
@@ -385,20 +385,24 @@ pub fn malloc_raw(bcx: @mut Block, t: ty::t, heap: heap) -> Result {
 
 pub struct MallocResult {
     bcx: @mut Block,
-    box: ValueRef,
+    smart_ptr: ValueRef,
     body: ValueRef
 }
 
-// malloc_general_dyn: usefully wraps malloc_raw_dyn; allocates a box,
-// and pulls out the body
+// malloc_general_dyn: usefully wraps malloc_raw_dyn; allocates a smart
+// pointer, and pulls out the body
 pub fn malloc_general_dyn(bcx: @mut Block, t: ty::t, heap: heap, size: ValueRef)
     -> MallocResult {
     assert!(heap != heap_exchange);
     let _icx = push_ctxt("malloc_general");
     let Result {bcx: bcx, val: llbox} = malloc_raw_dyn(bcx, t, heap, size);
     let body = GEPi(bcx, llbox, [0u, abi::box_field_body]);
 
-    MallocResult { bcx: bcx, box: llbox, body: body }
+    MallocResult {
+        bcx: bcx,
+        smart_ptr: llbox,
+        body: body,
+    }
 }
 
 pub fn malloc_general(bcx: @mut Block, t: ty::t, heap: heap) -> MallocResult {
@@ -871,8 +875,11 @@ pub fn trans_external_path(ccx: &mut CrateContext, did: ast::DefId, t: ty::t) ->
     }
 }
 
-pub fn invoke(bcx: @mut Block, llfn: ValueRef, llargs: ~[ValueRef],
-              attributes: &[(uint, lib::llvm::Attribute)])
+pub fn invoke(bcx: @mut Block,
+              llfn: ValueRef,
+              llargs: ~[ValueRef],
+              attributes: &[(uint, lib::llvm::Attribute)],
+              call_info: Option<NodeInfo>)
            -> (ValueRef, @mut Block) {
     let _icx = push_ctxt("invoke_");
     if bcx.unreachable {
@@ -895,11 +902,18 @@ pub fn invoke(bcx: @mut Block, llfn: ValueRef, llargs: ~[ValueRef],
             }
         }
         let normal_bcx = sub_block(bcx, "normal return");
+        let landing_pad = get_landing_pad(bcx);
+
+        match call_info {
+            Some(info) => debuginfo::set_source_location(bcx.fcx, info.id, info.span),
+            None => debuginfo::clear_source_location(bcx.fcx)
+        };
+
         let llresult = Invoke(bcx,
                               llfn,
                               llargs,
                               normal_bcx.llbb,
-                              get_landing_pad(bcx),
+                              landing_pad,
                               attributes);
         return (llresult, normal_bcx);
     } else {
@@ -909,6 +923,12 @@ pub fn invoke(bcx: @mut Block, llfn: ValueRef, llargs: ~[ValueRef],
                 debug!("arg: {}", llarg);
             }
         }
+
+        match call_info {
+            Some(info) => debuginfo::set_source_location(bcx.fcx, info.id, info.span),
+            None => debuginfo::clear_source_location(bcx.fcx)
+        };
+
         let llresult = Call(bcx, llfn, llargs, attributes);
         return (llresult, bcx);
     }
@@ -1547,6 +1567,7 @@ pub fn alloca_maybe_zeroed(cx: @mut Block, ty: Type, name: &str, zero: bool) ->
             return llvm::LLVMGetUndef(ty.ptr_to().to_ref());
         }
     }
+    debuginfo::clear_source_location(cx.fcx);
     let p = Alloca(cx, ty, name);
     if zero {
         let b = cx.fcx.ccx.builder();
@@ -1563,6 +1584,7 @@ pub fn arrayalloca(cx: @mut Block, ty: Type, v: ValueRef) -> ValueRef {
             return llvm::LLVMGetUndef(ty.to_ref());
         }
     }
+    debuginfo::clear_source_location(cx.fcx);
     return ArrayAlloca(cx, ty, v);
 }
 
@@ -1806,6 +1828,7 @@ pub fn finish_fn(fcx: @mut FunctionContext, last_bcx: @mut Block) {
         None => last_bcx
     };
     build_return_block(fcx, ret_cx);
+    debuginfo::clear_source_location(fcx);
     fcx.cleanup();
 }
 

branches/try2/src/librustc/middle/trans/callee.rs

@@ -697,7 +697,7 @@ pub fn trans_call_inner(in_cx: @mut Block,
             }
 
             // Invoke the actual rust fn and update bcx/llresult.
-            let (llret, b) = base::invoke(bcx, llfn, llargs, attrs);
+            let (llret, b) = base::invoke(bcx, llfn, llargs, attrs, call_info);
             bcx = b;
             llresult = llret;
 

branches/try2/src/librustc/middle/trans/debuginfo.rs

@@ -85,6 +85,43 @@ continuation, storing all state needed to continue traversal at the type members
 been registered with the cache. (This implementation approach might be a tad over-engineered and
 may change in the future)
 
+
+## Source Locations and Line Information
+In addition to data type descriptions the debugging information must also allow to map machine code
+locations back to source code locations in order to be useful. This functionality is also handled in
+this module. The following functions allow to control source mappings:
+
++ set_source_location()
++ clear_source_location()
++ start_emitting_source_locations()
+
+`set_source_location()` allows to set the current source location. All IR instructions created after
+a call to this function will be linked to the given source location, until another location is
+specified with `set_source_location()` or the source location is cleared with
+`clear_source_location()`. In the later case, subsequent IR instruction will not be linked to any
+source location. As you can see, this is a stateful API (mimicking the one in LLVM), so be careful
+with source locations set by previous calls. It's probably best to not rely on any specific state
+being present at a given point in code.
+
+One topic that deserves some extra attention is *function prologues*. At the beginning of a
+function's machine code there are typically a few instructions for loading argument values into
+allocas and checking if there's enough stack space for the function to execute. This *prologue* is
+not visible in the source code and LLVM puts a special PROLOGUE END marker into the line table at
+the first non-prologue instruction of the function. In order to find out where the prologue ends,
+LLVM looks for the first instruction in the function body that is linked to a source location. So,
+when generating prologue instructions we have to make sure that we don't emit source location
+information until the 'real' function body begins. For this reason, source location emission is
+disabled by default for any new function being translated and is only activated after a call to the
+third function from the list above, `start_emitting_source_locations()`. This function should be
+called right before regularly starting to translate the top-level block of the given function.
+
+There is one exception to the above rule: `llvm.dbg.declare` instruction must be linked to the
+source location of the variable being declared. For function parameters these `llvm.dbg.declare`
+instructions typically occur in the middle of the prologue, however, they are ignored by LLVM's
+prologue detection. The `create_argument_metadata()` and related functions take care of linking the
+`llvm.dbg.declare` instructions to the correct source locations even while source location emission
+is still disabled, so there is no need to do anything special with source location handling here.
+
 */
 
 
@@ -651,7 +688,16 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
         (function_name.clone(), file_metadata)
     };
 
-    let scope_line = get_scope_line(cx, top_level_block, loc.line);
+    // Clang sets this parameter to the opening brace of the function's block, so let's do this too.
+    let scope_line = span_start(cx, top_level_block.span).line;
+
+    // The is_local_to_unit flag indicates whether a function is local to the current compilation
+    // unit (i.e. if it is *static* in the C-sense). The *reachable* set should provide a good
+    // approximation of this, as it contains everything that might leak out of the current crate
+    // (by being externally visible or by being inlined into something externally visible). It might
+    // better to use the `exported_items` set from `driver::CrateAnalysis` in the future, but (atm)
+    // this set is not available in the translation pass.
+    let is_local_to_unit = !cx.reachable.contains(&fn_ast_id);
 
     let fn_metadata = function_name.with_c_str(|function_name| {
                           linkage_name.with_c_str(|linkage_name| {
@@ -664,7 +710,7 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
                     file_metadata,
                     loc.line as c_uint,
                     function_type_metadata,
-                    false,
+                    is_local_to_unit,
                     true,
                     scope_line as c_uint,
                     FlagPrototyped as c_uint,
@@ -687,6 +733,9 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
     let arg_pats = fn_decl.inputs.map(|arg_ref| arg_ref.pat);
     populate_scope_map(cx, arg_pats, top_level_block, fn_metadata, &mut fn_debug_context.scope_map);
 
+    // Clear the debug location so we don't assign them in the function prelude
+    set_debug_location(cx, UnknownLocation);
+
     return FunctionDebugContext(fn_debug_context);
 
     fn get_function_signature(cx: &mut CrateContext,
@@ -837,21 +886,6 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
 
         return create_DIArray(DIB(cx), template_params);
     }
-
-    fn get_scope_line(cx: &CrateContext,
-                      top_level_block: &ast::Block,
-                      default: uint)
-                   -> uint {
-        match *top_level_block {
-            ast::Block { stmts: ref statements, .. } if statements.len() > 0 => {
-                span_start(cx, statements[0].span).line
-            }
-            ast::Block { expr: Some(@ref expr), .. } => {
-                span_start(cx, expr.span).line
-            }
-            _ => default
-        }
-    }
 }
 
 //=-------------------------------------------------------------------------------------------------
@@ -1683,7 +1717,7 @@ fn boxed_type_metadata(cx: &mut CrateContext,
         None                    => ~"BoxedType"
     };
 
-    let box_llvm_type = Type::box(cx, &content_llvm_type);
+    let box_llvm_type = Type::smart_ptr(cx, &content_llvm_type);
     let member_llvm_types = box_llvm_type.field_types();
     assert!(box_layout_is_correct(cx, member_llvm_types, content_llvm_type));
 
@@ -2128,7 +2162,8 @@ fn set_debug_location(cx: &mut CrateContext, debug_location: DebugLocation) {
     let metadata_node;
 
     match debug_location {
-        KnownLocation { scope, line, col } => {
+        KnownLocation { scope, line, .. } => {
+            let col = 0; // Always set the column to zero like Clang and GCC
             debug!("setting debug location to {} {}", line, col);
             let elements = [C_i32(line as i32), C_i32(col as i32), scope, ptr::null()];
             unsafe {
@@ -2244,7 +2279,14 @@ fn populate_scope_map(cx: &mut CrateContext,
         })
     }
 
-    walk_block(cx, fn_entry_block, &mut scope_stack, scope_map);
+    // Clang creates a separate scope for function bodies, so let's do this too
+    with_new_scope(cx,
+                   fn_entry_block.span,
+                   &mut scope_stack,
+                   scope_map,
+                   |cx, scope_stack, scope_map| {
+        walk_block(cx, fn_entry_block, scope_stack, scope_map);
+    });
 
     // local helper functions for walking the AST.
     fn with_new_scope(cx: &mut CrateContext,

branches/try2/src/librustc/middle/trans/expr.rs

@@ -1396,8 +1396,11 @@ fn trans_unary_datum(bcx: @mut Block,
             revoke_clean(bcx, val);
             return immediate_rvalue_bcx(bcx, val, box_ty);
         } else {
-            let base::MallocResult { bcx, box: bx, body } =
-                base::malloc_general(bcx, contents_ty, heap);
+            let base::MallocResult {
+                bcx,
+                smart_ptr: bx,
+                body
+            } = base::malloc_general(bcx, contents_ty, heap);
             add_clean_free(bcx, bx, heap);
             let bcx = trans_into(bcx, contents, SaveIn(body));
             revoke_clean(bcx, bx);

branches/try2/src/librustc/middle/trans/glue.rs

@@ -429,7 +429,7 @@ pub fn trans_struct_drop(bcx: @mut Block, t: ty::t, v0: ValueRef, dtor_did: ast:
             add_clean(bcx, llfld_a, fld.mt.ty);
         }
 
-        let (_, bcx) = invoke(bcx, dtor_addr, args, []);
+        let (_, bcx) = invoke(bcx, dtor_addr, args, [], None);
         bcx
     })
 }

branches/try2/src/librustc/middle/trans/tvec.rs

@@ -98,7 +98,7 @@ pub fn alloc_raw(bcx: @mut Block, unit_ty: ty::t,
         Store(bcx, alloc, GEPi(bcx, val, [0u, abi::vec_elt_alloc]));
         return rslt(bcx, val);
     } else {
-        let base::MallocResult {bcx, box: bx, body} =
+        let base::MallocResult {bcx, smart_ptr: bx, body} =
             base::malloc_general_dyn(bcx, vecbodyty, heap, vecsize);
         Store(bcx, fill, GEPi(bcx, body, [0u, abi::vec_elt_fill]));
         Store(bcx, alloc, GEPi(bcx, body, [0u, abi::vec_elt_alloc]));