---

yaml
---
r: 128701
b: refs/heads/try
c: 69c58bc
h: refs/heads/master
i:
  128699: 8f7c2b5
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 71df8e655c1a7a435082de753694821f359fb8a9
+refs/heads/try: 69c58bcf6f8392c078e5f4ea0281e904cd8e8afb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/CONTRIBUTING.md

@@ -16,7 +16,8 @@ please do two things:
 
 2. Run the full Rust test suite with the `make check` command.  You're
    not off the hook even if you just stick to documentation; code
-   examples in the docs are tested as well!
+   examples in the docs are tested as well! Although for simple
+   wording or grammar fixes, this is probably unnecessary.
 
 Pull requests will be treated as "review requests", and we will give
 feedback we expect to see corrected on

branches/try/mk/main.mk

@@ -139,6 +139,10 @@ endif
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
 
+# Landing pads require a lot of codegen. We can get through bootstrapping faster
+# by not emitting them.
+RUSTFLAGS_STAGE0 += -Z no-landing-pads
+
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 

branches/try/src/doc/guide-pointers.md

@@ -655,7 +655,7 @@ This part is coming soon.
 # Returning Pointers
 
 In many languages with pointers, you'd return a pointer from a function
-so as to avoid a copying a large data structure. For example:
+so as to avoid copying a large data structure. For example:
 
 ```{rust}
 struct BigStruct {

branches/try/src/libcore/num/f32.rs

@@ -293,7 +293,7 @@ impl Float for f32 {
     #[inline]
     fn frac_pi_8() -> f32 { consts::FRAC_PI_8 }
 
-    /// 1 .0/ pi
+    /// 1.0 / pi
     #[inline]
     fn frac_1_pi() -> f32 { consts::FRAC_1_PI }
 

branches/try/src/librustc/back/link.rs

@@ -1400,6 +1400,20 @@ fn link_args(cmd: &mut Command,
         cmd.arg("-Wl,--gc-sections");
     }
 
+    let used_link_args = sess.cstore.get_used_link_args().borrow();
+
+    // Dynamically linked executables can be compiled as position independent if the default
+    // relocation model of position independent code is not changed. This is a requirement to take
+    // advantage of ASLR, as otherwise the functions in the executable are not randomized and can
+    // be used during an exploit of a vulnerability in any code.
+    if sess.targ_cfg.os == abi::OsLinux {
+        let mut args = sess.opts.cg.link_args.iter().chain(used_link_args.iter());
+        if !dylib && sess.opts.cg.relocation_model.as_slice() == "pic" &&
+            !args.any(|x| x.as_slice() == "-static") {
+            cmd.arg("-pie");
+        }
+    }
+
     if sess.targ_cfg.os == abi::OsLinux || sess.targ_cfg.os == abi::OsDragonfly {
         // GNU-style linkers will use this to omit linking to libraries which
         // don't actually fulfill any relocations, but only for libraries which
@@ -1568,9 +1582,7 @@ fn link_args(cmd: &mut Command,
     // Finally add all the linker arguments provided on the command line along
     // with any #[link_args] attributes found inside the crate
     cmd.args(sess.opts.cg.link_args.as_slice());
-    for arg in sess.cstore.get_used_link_args().borrow().iter() {
-        cmd.arg(arg.as_slice());
-    }
+    cmd.args(used_link_args.as_slice());
 }
 
 // # Native library linking

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

@@ -1932,7 +1932,8 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
                                                         llfn,
                                                         &param_substs::empty(),
                                                         item.id,
-                                                        None);
+                                                        None,
+                                                        TranslateItems);
             } else {
                 trans_fn(ccx,
                          &**decl,

branches/try/src/librustc/middle/trans/cabi.rs

@@ -13,10 +13,12 @@ use std::option;
 use middle::trans::context::CrateContext;
 use middle::trans::cabi_x86;
 use middle::trans::cabi_x86_64;
+use middle::trans::cabi_x86_win64;
 use middle::trans::cabi_arm;
 use middle::trans::cabi_mips;
 use middle::trans::type_::Type;
 use syntax::abi::{X86, X86_64, Arm, Mips, Mipsel};
+use syntax::abi::{OsWin32};
 
 #[deriving(Clone, PartialEq)]
 pub enum ArgKind {
@@ -107,7 +109,12 @@ pub fn compute_abi_info(ccx: &CrateContext,
                         ret_def: bool) -> FnType {
     match ccx.sess().targ_cfg.arch {
         X86 => cabi_x86::compute_abi_info(ccx, atys, rty, ret_def),
-        X86_64 => cabi_x86_64::compute_abi_info(ccx, atys, rty, ret_def),
+        X86_64 =>
+            if ccx.sess().targ_cfg.os == OsWin32 {
+                cabi_x86_win64::compute_abi_info(ccx, atys, rty, ret_def)
+            } else {
+                cabi_x86_64::compute_abi_info(ccx, atys, rty, ret_def)
+            },
         Arm => cabi_arm::compute_abi_info(ccx, atys, rty, ret_def),
         Mips => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def),
         Mipsel => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def),

branches/try/src/librustc/middle/trans/cabi_x86_win64.rs

@@ -0,0 +1,64 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use llvm::*;
+use super::cabi::*;
+use super::common::*;
+use super::machine::*;
+use middle::trans::type_::Type;
+
+// Win64 ABI: http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
+
+pub fn compute_abi_info(ccx: &CrateContext,
+                          atys: &[Type],
+                          rty: Type,
+                          ret_def: bool) -> FnType {
+    let mut arg_tys = Vec::new();
+
+    let ret_ty;
+    if !ret_def {
+        ret_ty = ArgType::direct(Type::void(ccx), None, None, None);
+    } else if rty.kind() == Struct {
+        ret_ty = match llsize_of_alloc(ccx, rty) {
+            1 => ArgType::direct(rty, Some(Type::i8(ccx)), None, None),
+            2 => ArgType::direct(rty, Some(Type::i16(ccx)), None, None),
+            4 => ArgType::direct(rty, Some(Type::i32(ccx)), None, None),
+            8 => ArgType::direct(rty, Some(Type::i64(ccx)), None, None),
+            _ => ArgType::indirect(rty, Some(StructRetAttribute))
+        };
+    } else {
+        let attr = if rty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
+        ret_ty = ArgType::direct(rty, None, None, attr);
+    }
+
+    for &t in atys.iter() {
+        let ty = match t.kind() {
+            Struct => {
+                match llsize_of_alloc(ccx, t) {
+                    1 => ArgType::direct(rty, Some(Type::i8(ccx)), None, None),
+                    2 => ArgType::direct(rty, Some(Type::i16(ccx)), None, None),
+                    4 => ArgType::direct(rty, Some(Type::i32(ccx)), None, None),
+                    8 => ArgType::direct(rty, Some(Type::i64(ccx)), None, None),
+                    _ => ArgType::indirect(t, Some(ByValAttribute))
+                }
+            }
+            _ => {
+                let attr = if t == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
+                ArgType::direct(t, None, None, attr)
+            }
+        };
+        arg_tys.push(ty);
+    }
+
+    return FnType {
+        arg_tys: arg_tys,
+        ret_ty: ret_ty,
+    };
+}

branches/try/src/librustc/middle/trans/foreign.rs

@@ -577,7 +577,8 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
                                       llwrapfn: ValueRef,
                                       param_substs: &param_substs,
                                       id: ast::NodeId,
-                                      hash: Option<&str>) {
+                                      hash: Option<&str>,
+                                      handle_items: HandleItemsFlag) {
     let _icx = push_ctxt("foreign::build_foreign_fn");
 
     let fnty = ty::node_id_to_type(ccx.tcx(), id);
@@ -586,7 +587,8 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
 
     unsafe { // unsafe because we call LLVM operations
         // Build up the Rust function (`foo0` above).
-        let llrustfn = build_rust_fn(ccx, decl, body, param_substs, attrs, id, hash);
+        let llrustfn = build_rust_fn(ccx, decl, body, param_substs, attrs, id,
+                                     hash, handle_items);
 
         // Build up the foreign wrapper (`foo` above).
         return build_wrap_fn(ccx, llrustfn, llwrapfn, &tys, mty);
@@ -598,7 +600,8 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
                      param_substs: &param_substs,
                      attrs: &[ast::Attribute],
                      id: ast::NodeId,
-                     hash: Option<&str>)
+                     hash: Option<&str>,
+                     handle_items: HandleItemsFlag)
                      -> ValueRef {
         let _icx = push_ctxt("foreign::foreign::build_rust_fn");
         let tcx = ccx.tcx();
@@ -630,7 +633,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
 
         let llfn = base::decl_internal_rust_fn(ccx, t, ps.as_slice());
         base::set_llvm_fn_attrs(attrs, llfn);
-        base::trans_fn(ccx, decl, body, llfn, param_substs, id, [], TranslateItems);
+        base::trans_fn(ccx, decl, body, llfn, param_substs, id, [], handle_items);
         llfn
     }
 

branches/try/src/librustc/middle/trans/mod.rs

@@ -31,6 +31,7 @@ pub mod meth;
 pub mod cabi;
 pub mod cabi_x86;
 pub mod cabi_x86_64;
+pub mod cabi_x86_win64;
 pub mod cabi_arm;
 pub mod cabi_mips;
 pub mod foreign;

branches/try/src/librustc/middle/trans/monomorphize.rs

@@ -164,7 +164,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
                   if abi != abi::Rust {
                       foreign::trans_rust_fn_with_foreign_abi(
                           ccx, &**decl, &**body, [], d, &psubsts, fn_id.node,
-                          Some(hash.as_slice()));
+                          Some(hash.as_slice()), IgnoreItems);
                   } else {
                       trans_fn(ccx, &**decl, &**body, d, &psubsts, fn_id.node, [],
                                IgnoreItems);

branches/try/src/librustdoc/html/layout.rs

@@ -106,7 +106,7 @@ r##"<!DOCTYPE html>
             </p>
             <p>
                 Accepted types are: <code>fn</code>, <code>mod</code>,
-                <code>struct</code> (or <code>str</code>), <code>enum</code>,
+                <code>struct</code>, <code>enum</code>,
                 <code>trait</code>, <code>typedef</code> (or
                 <code>tdef</code>).
             </p>

branches/try/src/librustdoc/html/static/main.js

@@ -368,18 +368,19 @@
         }
 
         function getQuery() {
-            var matches, type, query = $('.search-input').val();
+            var matches, type, query, raw = $('.search-input').val();
+            query = raw;
 
-            matches = query.match(/^(fn|mod|str(uct)?|enum|trait|t(ype)?d(ef)?)\s*:\s*/i);
+            matches = query.match(/^(fn|mod|struct|enum|trait|t(ype)?d(ef)?)\s*:\s*/i);
             if (matches) {
                 type = matches[1].replace(/^td$/, 'typedef')
-                                 .replace(/^str$/, 'struct')
                                  .replace(/^tdef$/, 'typedef')
                                  .replace(/^typed$/, 'typedef');
                 query = query.substring(matches[0].length);
             }
 
             return {
+                raw: raw,
                 query: query,
                 type: type,
                 id: query + type,
@@ -535,10 +536,10 @@
             if (browserSupportsHistoryApi()) {
                 if (!history.state && !params.search) {
                     history.pushState(query, "", "?search=" +
-                                                encodeURIComponent(query.query));
+                                                encodeURIComponent(query.raw));
                 } else {
                     history.replaceState(query, "", "?search=" +
-                                                encodeURIComponent(query.query));
+                                                encodeURIComponent(query.raw));
                 }
             }
 

branches/try/src/librustdoc/lib.rs

@@ -120,9 +120,16 @@ pub fn main() {
     // So, in summary, it is unknown why this is necessary, what it is
     // preventing, or what the actual bug is. In the meantime, this allows
     // --test to work on windows, which seems good, right? Fun times.
+    let (tx, rx) = channel();
     spawn(proc() {
         std::os::set_exit_status(main_args(std::os::args().as_slice()));
+        tx.send(());
     });
+
+    // If the task failed, set an error'd exit status
+    if rx.recv_opt().is_err() {
+        std::os::set_exit_status(std::rt::DEFAULT_ERROR_CODE);
+    }
 }
 
 pub fn opts() -> Vec<getopts::OptGroup> {

branches/try/src/test/compile-fail/repeat_count.rs

@@ -23,4 +23,6 @@ fn main() {
     //~^ ERROR: expected `uint` but found `&'static str`
     let f = [0, ..-4];
     //~^ ERROR expected positive integer for repeat count but found negative integer
+    let f = [0u, ..-1];
+    //~^ ERROR expected positive integer for repeat count but found negative integer
 }

branches/try/src/test/run-make/issue-7349/Makefile

@@ -2,10 +2,10 @@
 
 # Test to make sure that inner functions within a polymorphic outer function
 # don't get re-translated when the outer function is monomorphized.  The test
-# code monomorphizes the outer function several times, but the magic constant
-# `8675309` used in the inner function should appear only once in the generated
-# IR.
+# code monomorphizes the outer functions several times, but the magic constants
+# used in the inner functions should each appear only once in the generated IR.
 
 all:
 	$(RUSTC) foo.rs --emit=ir
 	[ "$$(grep -c 8675309 "$(TMPDIR)/foo.ll")" -eq "1" ]
+	[ "$$(grep -c 11235813 "$(TMPDIR)/foo.ll")" -eq "1" ]

branches/try/src/test/run-make/issue-7349/foo.rs

@@ -15,7 +15,16 @@ fn outer<T>() {
     }
 }
 
+extern "C" fn outer_foreign<T>() {
+    #[allow(dead_code)]
+    fn inner() -> uint {
+        11235813
+    }
+}
+
 fn main() {
     outer::<int>();
     outer::<uint>();
+    outer_foreign::<int>();
+    outer_foreign::<uint>();
 }