---

yaml
---
r: 274645
b: refs/heads/stable
c: ad73330
h: refs/heads/master
i:
  274643: b124388

Author: reem

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 8c604dc940c35e4ac36012aa85375250f2e6e07e
+refs/heads/stable: ad73330391d7b608e6650cb83dc76d5eeb1919ed
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/configure

@@ -1305,12 +1305,6 @@ $ pacman -R cmake && pacman -S mingw-w64-x86_64-cmake
             putvar CFG_DISABLE_JEMALLOC
             ;;
 
-        *-emscripten)
-            step_msg "targeting emscripten, disabling jemalloc"
-            CFG_DISABLE_JEMALLOC=1
-            putvar CFG_DISABLE_JEMALLOC
-            ;;
-
         *)
             ;;
     esac

branches/stable/mk/cfg/asmjs-unknown-emscripten.mk

@@ -361,9 +361,6 @@ export CFG_DISABLE_UNSTABLE_FEATURES
 export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY)
 endif
 export CFG_BOOTSTRAP_KEY
-ifdef CFG_MUSL_ROOT
-export CFG_MUSL_ROOT
-endif
 
 ######################################################################
 # Per-stage targets and runner

branches/stable/mk/cfg/i686-unknown-linux-musl.mk

@@ -254,15 +254,6 @@ ifeq ($$(findstring freebsd,$(1)),freebsd)
 	COMPRT_CFLAGS_$(1) += -I/usr/include/c++/v1
 endif
 
-ifeq ($$(findstring emscripten,$(1)),emscripten)
-
-# FIXME: emscripten doesn't use compiler-rt and can't build it without
-# further hacks
-$$(COMPRT_LIB_$(1)):
-	touch $$@
-
-else
-
 $$(COMPRT_LIB_$(1)): $$(COMPRT_DEPS) $$(MKFILE_DEPS)
 	@$$(call E, make: compiler-rt)
 	$$(Q)$$(MAKE) -C "$(S)src/compiler-rt" \
@@ -275,10 +266,7 @@ $$(COMPRT_LIB_$(1)): $$(COMPRT_DEPS) $$(MKFILE_DEPS)
 		TargetTriple=$(1) \
 		triple-builtins
 	$$(Q)cp $$(COMPRT_BUILD_DIR_$(1))/triple/builtins/libcompiler_rt.a $$@
-
-endif # if emscripten
 endif
-
 ################################################################################
 # libbacktrace
 #
@@ -313,12 +301,6 @@ $$(BACKTRACE_LIB_$(1)):
 	touch $$@
 else
 
-ifeq ($$(findstring emscripten,$(1)),emscripten)
-# FIXME: libbacktrace doesn't understand the emscripten triple
-$$(BACKTRACE_LIB_$(1)):
-	touch $$@
-else
-
 ifdef CFG_ENABLE_FAST_MAKE
 BACKTRACE_DEPS := $(S)/.gitmodules
 else
@@ -366,7 +348,6 @@ $$(BACKTRACE_LIB_$(1)): $$(BACKTRACE_BUILD_DIR_$(1))/Makefile $$(MKFILE_DEPS)
 		INCDIR=$(S)src/libbacktrace
 	$$(Q)cp $$(BACKTRACE_BUILD_DIR_$(1))/.libs/libbacktrace.a $$@
 
-endif # endif for emscripten
 endif # endif for msvc
 endif # endif for ios
 endif # endif for darwin

branches/stable/mk/main.mk

@@ -1357,12 +1357,7 @@ fn make_lib_name(config: &Config, auxfile: &Path, testfile: &Path) -> PathBuf {
 
 fn make_exe_name(config: &Config, testfile: &Path) -> PathBuf {
     let mut f = output_base_name(config, testfile);
-    // FIXME: This is using the host architecture exe suffix, not target!
-    if config.target == "asmjs-unknown-emscripten" {
-        let mut fname = f.file_name().unwrap().to_os_string();
-        fname.push(".js");
-        f.set_file_name(&fname);
-    } else if !env::consts::EXE_SUFFIX.is_empty() {
+    if !env::consts::EXE_SUFFIX.is_empty() {
         let mut fname = f.file_name().unwrap().to_os_string();
         fname.push(env::consts::EXE_SUFFIX);
         f.set_file_name(&fname);
@@ -1375,12 +1370,6 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path)
     // If we've got another tool to run under (valgrind),
     // then split apart its command
     let mut args = split_maybe_args(&config.runtool);
-
-    // If this is emscripten, then run tests under nodejs
-    if config.target == "asmjs-unknown-emscripten" {
-        args.push("nodejs".to_owned());
-    }
-
     let exe_file = make_exe_name(config, testfile);
 
     // FIXME (#9639): This needs to handle non-utf8 paths

branches/stable/mk/rt.mk

@@ -26,7 +26,6 @@ const OS_TABLE: &'static [(&'static str, &'static str)] = &[
     ("win32", "windows"),
     ("windows", "windows"),
     ("solaris", "solaris"),
-    ("emscripten", "emscripten"),
 ];
 
 const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[
@@ -45,7 +44,6 @@ const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[
     ("sparc", "sparc"),
     ("x86_64", "x86_64"),
     ("xcore", "xcore"),
-    ("asmjs", "asmjs"),
 ];
 
 pub fn get_os(triple: &str) -> &'static str {

branches/stable/src/compiletest/runtest.rs

@@ -39,17 +39,11 @@ unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
 
     p
 }
-
 #[lang = "exchange_free"]
 unsafe fn deallocate(ptr: *mut u8, _size: usize, _align: usize) {
     libc::free(ptr as *mut libc::c_void)
 }
 
-#[lang = "box_free"]
-unsafe fn box_free<T>(ptr: *mut T) {
-    deallocate(ptr as *mut u8, ::core::mem::size_of::<T>(), ::core::mem::align_of::<T>());
-}
-
 #[start]
 fn main(argc: isize, argv: *const *const u8) -> isize {
     let x = box 1;

branches/stable/src/compiletest/util.rs

@@ -16,7 +16,7 @@ use std::mem::transmute;
 #[allow(dead_code)]
 pub const SEED: [u32; 3] = [0x243f_6a88, 0x85a3_08d3, 0x1319_8a2e];
 
-pub fn validate(text: &str) {
+pub fn validate(text: String) {
     let mut out = io::stdout();
     let x: f64 = text.parse().unwrap();
     let f64_bytes: u64 = unsafe { transmute(x) };

branches/stable/src/doc/book/lang-items.md

@@ -20,7 +20,7 @@ fn main() {
     for a in &pow {
         for b in &pow {
             for c in &pow {
-                validate(&(a | b | c).to_string());
+                validate((a | b | c).to_string());
             }
         }
     }

branches/stable/src/etc/test-float-parse/_common.rs

@@ -15,7 +15,7 @@ use _common::validate;
 fn main() {
     for e in 300..310 {
         for i in 0..100000 {
-            validate(&format!("{}e{}", i, e));
+            validate(format!("{}e{}", i, e));
         }
     }
 }

branches/stable/src/etc/test-float-parse/few-ones.rs

@@ -23,9 +23,9 @@ fn main() {
     let mut rnd = IsaacRng::from_seed(&SEED);
     let mut range = Range::new(0, 10);
     for _ in 0..5_000_000u64 {
-        let num_digits = rnd.gen_range(100, 400);
+        let num_digits = rnd.gen_range(100, 300);
         let digits = gen_digits(num_digits, &mut range, &mut rnd);
-        validate(&digits);
+        validate(digits);
     }
 }
 

branches/stable/src/etc/test-float-parse/huge-pow10.rs

@@ -25,7 +25,7 @@ fn main() {
         let bits = rnd.next_u64();
         let x: f64 = unsafe { transmute(bits) };
         if x.is_finite() {
-            validate(&format!("{:e}", x));
+            validate(format!("{:e}", x));
             i += 1;
         }
     }

branches/stable/src/etc/test-float-parse/long-fractions.rs

@@ -21,9 +21,8 @@
 
 The actual tests (generating decimal strings and feeding them to dec2flt) is
 performed by a set of stand-along rust programs. This script compiles, runs,
-and supervises them. The programs report the strings they generate and the
-floating point numbers they converted those strings to, and this script
-checks that the results are correct.
+and supervises them. In particular, the programs report the strings they
+generate and the floating point numbers they converted those strings to.
 
 You can run specific tests rather than all of them by giving their names
 (without .rs extension) as command line parameters.
@@ -65,9 +64,9 @@
 exit code that's not 0, the test fails.
 The output on stdout is treated as (f64, f32, decimal) record, encoded thusly:
 
-- First, the bits of the f64 encoded as an ASCII hex string.
-- Second, the bits of the f32 encoded as an ASCII hex string.
-- Then the corresponding string input, in ASCII
+- The first eight bytes are a binary64 (native endianness).
+- The following four bytes are a binary32 (native endianness).
+- Then the corresponding string input follows, in ASCII (no newline).
 - The record is terminated with a newline.
 
 Incomplete records are an error. Not-a-Number bit patterns are invalid too.

branches/stable/src/etc/test-float-parse/many-digits.rs

@@ -22,8 +22,8 @@ fn main() {
             if i % 10 == 0 {
                 continue;
             }
-            validate(&format!("{}e{}", i, e));
-            validate(&format!("{}e-{}", i, e));
+            validate(format!("{}e{}", i, e));
+            validate(format!("{}e-{}", i, e));
         }
     }
 }

branches/stable/src/etc/test-float-parse/rand-f64.rs

@@ -16,8 +16,8 @@ use _common::validate;
 fn main() {
     for bits in 0u32..(1 << 21) {
         let single: f32 = unsafe { transmute(bits) };
-        validate(&format!("{:e}", single));
+        validate(format!("{:e}", single));
         let double: f64 = unsafe { transmute(bits as u64) };
-        validate(&format!("{:e}", double));
+        validate(format!("{:e}", double));
     }
 }

branches/stable/src/etc/test-float-parse/runtests.py

@@ -15,7 +15,7 @@ use _common::validate;
 fn main() {
     for e in 301..327 {
         for i in 0..100000 {
-            validate(&format!("{}e-{}", i, e));
+            validate(format!("{}e-{}", i, e));
         }
     }
 }

branches/stable/src/etc/test-float-parse/short-decimals.rs

@@ -14,6 +14,6 @@ use _common::validate;
 
 fn main() {
     for i in 0..(1 << 19) {
-        validate(&i.to_string());
+        validate(i.to_string());
     }
 }

branches/stable/src/etc/test-float-parse/subnorm.rs

@@ -16,13 +16,13 @@ use std::u64;
 fn main() {
     for exp in 19..64 {
         let power: u64 = 1 << exp;
-        validate(&power.to_string());
+        validate(power.to_string());
         for offset in 1..123 {
-            validate(&(power + offset).to_string());
-            validate(&(power - offset).to_string());
+            validate((power + offset).to_string());
+            validate((power - offset).to_string());
         }
     }
     for offset in 0..123 {
-        validate(&(u64::MAX - offset).to_string());
+        validate((u64::MAX - offset).to_string());
     }
 }

branches/stable/src/etc/test-float-parse/tiny-pow10.rs

@@ -16,8 +16,6 @@
             issue = "27700")]
 
 use core::{isize, usize};
-#[cfg(not(test))]
-use core::intrinsics::{size_of, min_align_of};
 
 #[allow(improper_ctypes)]
 extern "C" {
@@ -149,17 +147,6 @@ unsafe fn exchange_free(ptr: *mut u8, old_size: usize, align: usize) {
     deallocate(ptr, old_size, align);
 }
 
-#[cfg(not(test))]
-#[lang = "box_free"]
-#[inline]
-unsafe fn box_free<T>(ptr: *mut T) {
-    let size = size_of::<T>();
-    // We do not allocate for Box<T> when T is ZST, so deallocation is also not necessary.
-    if size != 0 {
-        deallocate(ptr as *mut u8, size, min_align_of::<T>());
-    }
-}
-
 #[cfg(test)]
 mod tests {
     extern crate test;

branches/stable/src/etc/test-float-parse/u32-small.rs

@@ -30,8 +30,7 @@ extern crate libc;
               target_arch = "arm",
               target_arch = "mips",
               target_arch = "powerpc",
-              target_arch = "powerpc64",
-              target_arch = "asmjs")))]
+              target_arch = "powerpc64")))]
 const MIN_ALIGN: usize = 8;
 #[cfg(all(any(target_arch = "x86_64",
               target_arch = "aarch64")))]