---

yaml
---
r: 147277
b: refs/heads/try2
c: d952553
h: refs/heads/master
i:
  147275: 6c332d2
v: v3

Author: cartazio

[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: 000cda611f8224ac780fa37432f869f425cd2bb7
+refs/heads/try2: d9525530482f12f9814f46148ba02d3d1ecebee5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/configure

@@ -559,6 +559,27 @@ then
         step_msg "on OS X 10.9, forcing use of clang"
         CFG_ENABLE_CLANG=1
         putvar CFG_ENABLE_CLANG
+    else 
+        # on OS X, with xcode 5 and newer, certain developers may have 
+        # cc, gcc and g++ point to a  mixture of clang and gcc
+        # if so, this will create very strange build errors 
+        # this last stanza is to detect some such problems and save the future rust
+        # contributor some time solving that issue.
+        # this detection could be generalized to other OSes aside from OS X
+        # but the issue seems most likely to happen on OS X
+
+        chk_cc () {
+            $1 --version 2> /dev/null | grep -q $2
+        }
+        # check that gcc, cc and g++ all point to the same compiler.
+        # note that for xcode 5, g++ points to clang, not clang++
+        if !((chk_cc gcc clang  && chk_cc g++ clang) ||
+            (chk_cc gcc gcc  &&( chk_cc g++ g++ || chk g++ gcc))) then
+            err "the gcc and g++ in your path point to different compilers. 
+Check which versions are in your path with  cc --version and g++ --version. 
+To resolve this problem, either fix your PATH  or run configure with --enable-clang"
+        fi
+
     fi
 fi
 

branches/try2/doc/rust.md

@@ -2177,11 +2177,7 @@ 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.
 
-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`).
+[Path](#path-expressions), [field](#field-expressions) and [index](#index-expressions) expressions are lvalues.
 All other expressions are rvalues.
 
 The left operand of an [assignment](#assignment-expressions),

branches/try2/src/libextra/lib.rs

@@ -20,14 +20,22 @@ Rust extras are part of the standard Rust distribution.
 
 */
 
-#[pkgid = "extra#0.9-pre"];
+#[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")];
+
 #[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,8 +375,9 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item {
 }
 
 fn is_extra(crate: &ast::Crate) -> bool {
-    match attr::find_pkgid(crate.attrs) {
-        Some(ref s) if "extra" == s.name => true,
+    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,
         _ => false
     }
 }

branches/try2/src/librustc/lib.rs

@@ -8,7 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[pkgid = "rustc#0.9-pre"];
+#[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")];
+
 #[comment = "The Rust compiler"];
 #[license = "MIT/ASL2"];
 #[crate_type = "dylib"];

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

@@ -107,8 +107,6 @@ 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,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/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::smart_ptr(ccx, &ty);
+    let ty = Type::box(ccx, &ty);
     let boxptr = PointerCast(bcx, boxptr, ty.ptr_to());
     GEPi(bcx, boxptr, [0u, abi::box_field_body])
 }
@@ -385,24 +385,20 @@ pub fn malloc_raw(bcx: @mut Block, t: ty::t, heap: heap) -> Result {
 
 pub struct MallocResult {
     bcx: @mut Block,
-    smart_ptr: ValueRef,
+    box: ValueRef,
     body: ValueRef
 }
 
-// malloc_general_dyn: usefully wraps malloc_raw_dyn; allocates a smart
-// pointer, and pulls out the body
+// malloc_general_dyn: usefully wraps malloc_raw_dyn; allocates a box,
+// 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,
-        smart_ptr: llbox,
-        body: body,
-    }
+    MallocResult { bcx: bcx, box: llbox, body: body }
 }
 
 pub fn malloc_general(bcx: @mut Block, t: ty::t, heap: heap) -> MallocResult {
@@ -875,11 +871,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 +895,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 +909,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 +1547,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 +1563,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 +1806,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/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, call_info);
+            let (llret, b) = base::invoke(bcx, llfn, llargs, attrs);
             bcx = b;
             llresult = llret;
 

branches/try2/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
+        }
+    }
 }
 
 //=-------------------------------------------------------------------------------------------------
@@ -1717,7 +1683,7 @@ fn boxed_type_metadata(cx: &mut CrateContext,
         None                    => ~"BoxedType"
     };
 
-    let box_llvm_type = Type::smart_ptr(cx, &content_llvm_type);
+    let box_llvm_type = Type::box(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));
 
@@ -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,