Skip to content

Commit 1d011e0

Browse files
borsbors
committed
---
yaml --- r: 114579 b: refs/heads/master c: ff2bf58 h: refs/heads/master i: 114577: ae5e4d0 114575: 6280c33 v: v3
1 parent c4e8ffb commit 1d011e0

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

55 files changed

+1200
-1545
lines changed

‎[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
---
2-
refs/heads/master: 42aed6bde2fb05a262e21334656cdf91f51744dd
2+
refs/heads/master: ff2bf58e9e0c1e7b154b88fc7ba8c52584e9f768
33
refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
44
refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
55
refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

‎trunk/configure

Lines changed: 46 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -348,6 +348,11 @@ case $CFG_CPUTYPE in
348348
CFG_CPUTYPE=arm
349349
;;
350350

351+
armv7l)
352+
CFG_CPUTYPE=arm
353+
CFG_OSTYPE="${CFG_OSTYPE}eabihf"
354+
;;
355+
351356
x86_64 | x86-64 | x64 | amd64)
352357
CFG_CPUTYPE=x86_64
353358
;;
@@ -401,6 +406,7 @@ opt optimize 1 "build optimized rust code"
401406
opt optimize-cxx 1 "build optimized C++ code"
402407
opt optimize-llvm 1 "build optimized LLVM"
403408
opt optimize-tests 1 "build tests with optimizations"
409+
opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang"
404410
opt llvm-assertions 1 "build LLVM with assertions"
405411
opt debug 1 "build with extra debug fun"
406412
opt ratchet-bench 0 "ratchet benchmarks"
@@ -1043,53 +1049,71 @@ do
10431049

10441050
case "$CFG_CC" in
10451051
("ccache clang")
1046-
LLVM_CXX_32="ccache clang++ -m32 -Qunused-arguments"
1047-
LLVM_CC_32="ccache clang -m32 -Qunused-arguments"
1052+
LLVM_CXX_32="ccache clang++ -Qunused-arguments"
1053+
LLVM_CC_32="ccache clang -Qunused-arguments"
10481054

10491055
LLVM_CXX_64="ccache clang++ -Qunused-arguments"
10501056
LLVM_CC_64="ccache clang -Qunused-arguments"
1051-
LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
10521057
;;
10531058
("clang")
1054-
LLVM_CXX_32="clang++ -m32 -Qunused-arguments"
1055-
LLVM_CC_32="clang -m32 -Qunused-arguments"
1059+
LLVM_CXX_32="clang++ -Qunused-arguments"
1060+
LLVM_CC_32="clang -Qunused-arguments"
10561061

10571062
LLVM_CXX_64="clang++ -Qunused-arguments"
10581063
LLVM_CC_64="clang -Qunused-arguments"
1059-
LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
10601064
;;
10611065
("ccache gcc")
1062-
LLVM_CXX_32="ccache g++ -m32"
1063-
LLVM_CC_32="ccache gcc -m32"
1066+
LLVM_CXX_32="ccache g++"
1067+
LLVM_CC_32="ccache gcc"
10641068

10651069
LLVM_CXX_64="ccache g++"
10661070
LLVM_CC_64="ccache gcc"
10671071
;;
10681072
("gcc")
1069-
LLVM_CXX_32="g++ -m32"
1070-
LLVM_CC_32="gcc -m32"
1073+
LLVM_CXX_32="g++"
1074+
LLVM_CC_32="gcc"
10711075

10721076
LLVM_CXX_64="g++"
10731077
LLVM_CC_64="gcc"
10741078
;;
10751079

10761080
(*)
10771081
msg "inferring LLVM_CXX/CC from CXX/CC = $CXX/$CC"
1078-
LLVM_CXX_32="$CXX -m32"
1079-
LLVM_CC_32="$CC -m32"
1082+
LLVM_CXX_32="$CXX"
1083+
LLVM_CC_32="$CC"
10801084

10811085
LLVM_CXX_64="$CXX"
10821086
LLVM_CC_64="$CC"
10831087
;;
10841088
esac
10851089

1086-
LLVM_CFLAGS_32="-m32"
1087-
LLVM_CXXFLAGS_32="-m32"
1088-
LLVM_LDFLAGS_32="-m32"
1090+
case "$CFG_CPUTYPE" in
1091+
(x86*)
1092+
LLVM_CXX_32="$LLVM_CXX_32 -m32"
1093+
LLVM_CC_32="$LLVM_CC_32 -m32"
1094+
1095+
LLVM_CFLAGS_32="-m32"
1096+
LLVM_CXXFLAGS_32="-m32"
1097+
LLVM_LDFLAGS_32="-m32"
1098+
1099+
LLVM_CFLAGS_64=""
1100+
LLVM_CXXFLAGS_64=""
1101+
LLVM_LDFLAGS_64=""
1102+
1103+
LLVM_CXX_32="$LLVM_CXX_32 -m32"
1104+
LLVM_CC_32="$LLVM_CC_32 -m32"
1105+
;;
1106+
1107+
(*)
1108+
LLVM_CFLAGS_32=""
1109+
LLVM_CXXFLAGS_32=""
1110+
LLVM_LDFLAGS_32=""
10891111

1090-
LLVM_CFLAGS_64=""
1091-
LLVM_CXXFLAGS_64=""
1092-
LLVM_LDFLAGS_64=""
1112+
LLVM_CFLAGS_64=""
1113+
LLVM_CXXFLAGS_64=""
1114+
LLVM_LDFLAGS_64=""
1115+
;;
1116+
esac
10931117

10941118
if echo $t | grep -q x86_64
10951119
then
@@ -1112,6 +1136,10 @@ do
11121136
CXXFLAGS=$LLVM_CXXFLAGS
11131137
LDFLAGS=$LLVM_LDFLAGS
11141138

1139+
if [ "$CFG_DISABLE_LIBCPP" != 1 ] && [ "$CFG_USING_CLANG" == 1 ]; then
1140+
LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
1141+
fi
1142+
11151143
LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
11161144
$LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON"
11171145

‎trunk/mk/docs.mk

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -287,6 +287,7 @@ $(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPIL
287287
ifdef CFG_DISABLE_DOCS
288288
$(info cfg: disabling doc build (CFG_DISABLE_DOCS))
289289
DOC_TARGETS :=
290+
COMPILER_DOC_TARGETS :=
290291
endif
291292

292293
docs: $(DOC_TARGETS)

‎trunk/src/doc/rust.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1435,7 +1435,7 @@ trait Circle : Shape { fn radius() -> f64; }
14351435
~~~~
14361436

14371437
the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`.
1438-
Multiple supertraits are separated by spaces, `trait Circle : Shape Eq { }`.
1438+
Multiple supertraits are separated by `+`, `trait Circle : Shape + Eq { }`.
14391439
In an implementation of `Circle` for a given type `T`, methods can refer to `Shape` methods,
14401440
since the typechecker checks that any type with an implementation of `Circle` also has an implementation of `Shape`.
14411441

‎trunk/src/libcore/bool.rs

Lines changed: 0 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -10,28 +10,10 @@
1010

1111
//! Operations on boolean values (`bool` type)
1212
//!
13-
//! A quick summary:
14-
//!
15-
//! Implementations of the following traits:
16-
//!
17-
//! * `Not`
18-
//! * `BitAnd`
19-
//! * `BitOr`
20-
//! * `BitXor`
21-
//! * `Ord`
22-
//! * `TotalOrd`
23-
//! * `Eq`
24-
//! * `TotalEq`
25-
//! * `Default`
26-
//!
2713
//! A `to_bit` conversion function.
2814
2915
use num::{Int, one, zero};
3016

31-
#[cfg(not(test))] use cmp::{Eq, Ord, TotalOrd, Ordering, TotalEq};
32-
#[cfg(not(test))] use ops::{Not, BitAnd, BitOr, BitXor};
33-
#[cfg(not(test))] use default::Default;
34-
3517
/////////////////////////////////////////////////////////////////////////////
3618
// Freestanding functions
3719
/////////////////////////////////////////////////////////////////////////////
@@ -51,131 +33,6 @@ pub fn to_bit<N: Int>(p: bool) -> N {
5133
if p { one() } else { zero() }
5234
}
5335

54-
/////////////////////////////////////////////////////////////////////////////
55-
// Trait impls on `bool`
56-
/////////////////////////////////////////////////////////////////////////////
57-
58-
#[cfg(not(test))]
59-
impl Not<bool> for bool {
60-
/// The logical complement of a boolean value.
61-
///
62-
/// # Examples
63-
///
64-
/// ```rust
65-
/// assert_eq!(!true, false);
66-
/// assert_eq!(!false, true);
67-
/// ```
68-
#[inline]
69-
fn not(&self) -> bool { !*self }
70-
}
71-
72-
#[cfg(not(test))]
73-
impl BitAnd<bool, bool> for bool {
74-
/// Conjunction of two boolean values.
75-
///
76-
/// # Examples
77-
///
78-
/// ```rust
79-
/// assert_eq!(false.bitand(&false), false);
80-
/// assert_eq!(true.bitand(&false), false);
81-
/// assert_eq!(false.bitand(&true), false);
82-
/// assert_eq!(true.bitand(&true), true);
83-
///
84-
/// assert_eq!(false & false, false);
85-
/// assert_eq!(true & false, false);
86-
/// assert_eq!(false & true, false);
87-
/// assert_eq!(true & true, true);
88-
/// ```
89-
#[inline]
90-
fn bitand(&self, b: &bool) -> bool { *self & *b }
91-
}
92-
93-
#[cfg(not(test))]
94-
impl BitOr<bool, bool> for bool {
95-
/// Disjunction of two boolean values.
96-
///
97-
/// # Examples
98-
///
99-
/// ```rust
100-
/// assert_eq!(false.bitor(&false), false);
101-
/// assert_eq!(true.bitor(&false), true);
102-
/// assert_eq!(false.bitor(&true), true);
103-
/// assert_eq!(true.bitor(&true), true);
104-
///
105-
/// assert_eq!(false | false, false);
106-
/// assert_eq!(true | false, true);
107-
/// assert_eq!(false | true, true);
108-
/// assert_eq!(true | true, true);
109-
/// ```
110-
#[inline]
111-
fn bitor(&self, b: &bool) -> bool { *self | *b }
112-
}
113-
114-
#[cfg(not(test))]
115-
impl BitXor<bool, bool> for bool {
116-
/// An 'exclusive or' of two boolean values.
117-
///
118-
/// 'exclusive or' is identical to `or(and(a, not(b)), and(not(a), b))`.
119-
///
120-
/// # Examples
121-
///
122-
/// ```rust
123-
/// assert_eq!(false.bitxor(&false), false);
124-
/// assert_eq!(true.bitxor(&false), true);
125-
/// assert_eq!(false.bitxor(&true), true);
126-
/// assert_eq!(true.bitxor(&true), false);
127-
///
128-
/// assert_eq!(false ^ false, false);
129-
/// assert_eq!(true ^ false, true);
130-
/// assert_eq!(false ^ true, true);
131-
/// assert_eq!(true ^ true, false);
132-
/// ```
133-
#[inline]
134-
fn bitxor(&self, b: &bool) -> bool { *self ^ *b }
135-
}
136-
137-
#[cfg(not(test))]
138-
impl Ord for bool {
139-
#[inline]
140-
fn lt(&self, other: &bool) -> bool {
141-
to_bit::<u8>(*self) < to_bit(*other)
142-
}
143-
}
144-
145-
#[cfg(not(test))]
146-
impl TotalOrd for bool {
147-
#[inline]
148-
fn cmp(&self, other: &bool) -> Ordering {
149-
to_bit::<u8>(*self).cmp(&to_bit(*other))
150-
}
151-
}
152-
153-
/// Equality between two boolean values.
154-
///
155-
/// Two booleans are equal if they have the same value.
156-
///
157-
/// # Examples
158-
///
159-
/// ```rust
160-
/// assert_eq!(false.eq(&true), false);
161-
/// assert_eq!(false == false, true);
162-
/// assert_eq!(false != true, true);
163-
/// assert_eq!(false.ne(&false), false);
164-
/// ```
165-
#[cfg(not(test))]
166-
impl Eq for bool {
167-
#[inline]
168-
fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
169-
}
170-
171-
#[cfg(not(test))]
172-
impl TotalEq for bool {}
173-
174-
#[cfg(not(test))]
175-
impl Default for bool {
176-
fn default() -> bool { false }
177-
}
178-
17936
#[cfg(test)]
18037
mod tests {
18138
use realstd::prelude::*;

‎trunk/src/libcore/cell.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -482,6 +482,7 @@ mod test {
482482
}
483483

484484
#[test]
485+
#[allow(experimental)]
485486
fn clone_ref_updates_flag() {
486487
let x = RefCell::new(0);
487488
{

‎trunk/src/libcore/char.rs

Lines changed: 0 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -34,9 +34,6 @@ pub use unicode::normalization::decompose_canonical;
3434
/// Returns the compatibility decomposition of a character.
3535
pub use unicode::normalization::decompose_compatible;
3636

37-
#[cfg(not(test))] use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
38-
#[cfg(not(test))] use default::Default;
39-
4037
// UTF-8 ranges and tags for encoding characters
4138
static TAG_CONT: u8 = 0b1000_0000u8;
4239
static TAG_TWO_B: u8 = 0b1100_0000u8;
@@ -601,33 +598,6 @@ impl Char for char {
601598
}
602599
}
603600

604-
#[cfg(not(test))]
605-
impl Eq for char {
606-
#[inline]
607-
fn eq(&self, other: &char) -> bool { (*self) == (*other) }
608-
}
609-
610-
#[cfg(not(test))]
611-
impl TotalEq for char {}
612-
613-
#[cfg(not(test))]
614-
impl Ord for char {
615-
#[inline]
616-
fn lt(&self, other: &char) -> bool { *self < *other }
617-
}
618-
619-
#[cfg(not(test))]
620-
impl TotalOrd for char {
621-
fn cmp(&self, other: &char) -> Ordering {
622-
(*self as u32).cmp(&(*other as u32))
623-
}
624-
}
625-
626-
#[cfg(not(test))]
627-
impl Default for char {
628-
#[inline]
629-
fn default() -> char { '\x00' }
630-
}
631601

632602
#[cfg(test)]
633603
mod test {

0 commit comments

Comments
 (0)