---

yaml
---
r: 96735
b: refs/heads/dist-snap
c: 16f69b2
h: refs/heads/master
i:
  96733: 6267303
  96731: 5d2c5b8
  96727: 6e8dc6c
  96719: 312a072
  96703: 6319304
v: v3

Author: pnkfelix

[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: 35e5056b6a89d97d386416da44058cc736994ba9
+refs/heads/dist-snap: 16f69b225bdda1000610c5afda5d37dfd52ca306
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

@@ -220,7 +220,6 @@ 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;
@@ -2047,10 +2046,7 @@ 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 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();
+    let fast_path = !bcx.ccx().sess.opts.extra_debuginfo && simple_identifier(pat).is_some();
 
     if fast_path {
         // Optimized path for `x: T` case. This just adopts

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

@@ -875,11 +875,8 @@ 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)],
-              call_info: Option<NodeInfo>)
+pub fn invoke(bcx: @mut Block, llfn: ValueRef, llargs: ~[ValueRef],
+              attributes: &[(uint, lib::llvm::Attribute)])
            -> (ValueRef, @mut Block) {
     let _icx = push_ctxt("invoke_");
     if bcx.unreachable {
@@ -902,18 +899,11 @@ pub fn invoke(bcx: @mut Block,
             }
         }
         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,
-                              landing_pad,
+                              get_landing_pad(bcx),
                               attributes);
         return (llresult, normal_bcx);
     } else {
@@ -923,12 +913,6 @@ pub fn invoke(bcx: @mut Block,
                 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);
     }
@@ -1567,7 +1551,6 @@ 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();
@@ -1584,7 +1567,6 @@ 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);
 }
 
@@ -1828,7 +1810,6 @@ 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/dist-snap/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, call_info);
+            let (llret, b) = base::invoke(bcx, llfn, llargs, attrs);
             bcx = b;
             llresult = llret;
 

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

@@ -85,43 +85,6 @@ 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.
-
 */
 
 
@@ -688,16 +651,7 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
         (function_name.clone(), file_metadata)
     };
 
-    // 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 scope_line = get_scope_line(cx, top_level_block, loc.line);
 
     let fn_metadata = function_name.with_c_str(|function_name| {
                           linkage_name.with_c_str(|linkage_name| {
@@ -710,7 +664,7 @@ pub fn create_function_debug_context(cx: &mut CrateContext,
                     file_metadata,
                     loc.line as c_uint,
                     function_type_metadata,
-                    is_local_to_unit,
+                    false,
                     true,
                     scope_line as c_uint,
                     FlagPrototyped as c_uint,
@@ -733,9 +687,6 @@ 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,
@@ -886,6 +837,21 @@ 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
+        }
+    }
 }
 
 //=-------------------------------------------------------------------------------------------------
@@ -2162,8 +2128,7 @@ fn set_debug_location(cx: &mut CrateContext, debug_location: DebugLocation) {
     let metadata_node;
 
     match debug_location {
-        KnownLocation { scope, line, .. } => {
-            let col = 0; // Always set the column to zero like Clang and GCC
+        KnownLocation { scope, line, col } => {
             debug!("setting debug location to {} {}", line, col);
             let elements = [C_i32(line as i32), C_i32(col as i32), scope, ptr::null()];
             unsafe {
@@ -2279,14 +2244,7 @@ fn populate_scope_map(cx: &mut CrateContext,
         })
     }
 
-    // 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);
-    });
+    walk_block(cx, fn_entry_block, &mut scope_stack, scope_map);
 
     // local helper functions for walking the AST.
     fn with_new_scope(cx: &mut CrateContext,

branches/dist-snap/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, [], None);
+        let (_, bcx) = invoke(bcx, dtor_addr, args, []);
         bcx
     })
 }

branches/dist-snap/src/libstd/ptr.rs

@@ -21,14 +21,18 @@ use util::swap;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 
-/// Calculate the offset from a pointer
+/// Calculate the offset from a pointer.
+/// The `count` argument is in units of T; e.g. a `count` of 3
+/// represents a pointer offset of `3 * sizeof::<T>()` bytes.
 #[inline]
 pub unsafe fn offset<T>(ptr: *T, count: int) -> *T {
     intrinsics::offset(ptr, count)
 }
 
 /// Calculate the offset from a mut pointer. The count *must* be in bounds or
 /// otherwise the loads of this address are undefined.
+/// The `count` argument is in units of T; e.g. a `count` of 3
+/// represents a pointer offset of `3 * sizeof::<T>()` bytes.
 #[inline]
 pub unsafe fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
     intrinsics::offset(ptr as *T, count) as *mut T

branches/dist-snap/src/test/debug-info/basic-types-metadata.rs

@@ -45,7 +45,8 @@
 // debugger:whatis f64
 // check:type = f64
 // debugger:info functions _yyy
-// check:[...]![...]_yyy()();
+// check:[...]
+// check:![...]_yyy()();
 // debugger:detach
 // debugger:quit