diff --git a/src/liballoc/btree/set.rs b/src/liballoc/btree/set.rs
index 2807bbaca0c..e094070fc3d 100644
--- a/src/liballoc/btree/set.rs
+++ b/src/liballoc/btree/set.rs
@@ -415,6 +415,16 @@ impl<T: Ord> BTreeSet<T> {
/// The value may be any borrowed form of the set's value type,
/// but the ordering on the borrowed form *must* match the
/// ordering on the value type.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::collections::BTreeSet;
+ ///
+ /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// assert_eq!(set.get(&2), Some(&2));
+ /// assert_eq!(set.get(&4), None);
+ /// ```
#[stable(feature = "set_recovery", since = "1.9.0")]
pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T>
where T: Borrow<Q>,
@@ -540,6 +550,19 @@ impl<T: Ord> BTreeSet<T> {
/// Adds a value to the set, replacing the existing value, if any, that is equal to the given
/// one. Returns the replaced value.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::collections::BTreeSet;
+ ///
+ /// let mut set = BTreeSet::new();
+ /// set.insert(Vec::<i32>::new());
+ ///
+ /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 0);
+ /// set.replace(Vec::with_capacity(10));
+ /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 10);
+ /// ```
#[stable(feature = "set_recovery", since = "1.9.0")]
pub fn replace(&mut self, value: T) -> Option<T> {
Recover::replace(&mut self.map, value)
@@ -576,6 +599,16 @@ impl<T: Ord> BTreeSet<T> {
/// The value may be any borrowed form of the set's value type,
/// but the ordering on the borrowed form *must* match the
/// ordering on the value type.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::collections::BTreeSet;
+ ///
+ /// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// assert_eq!(set.take(&2), Some(2));
+ /// assert_eq!(set.take(&2), None);
+ /// ```
#[stable(feature = "set_recovery", since = "1.9.0")]
pub fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T>
where T: Borrow<Q>,
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index b89aa134e73..b5d24203b5e 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -439,7 +439,7 @@ macro_rules! int_impl {
}
/// Checked integer division. Computes `self / rhs`, returning `None`
- /// if `rhs == 0` or the operation results in overflow.
+ /// if `rhs == 0` or the division results in overflow.
///
/// # Examples
///
@@ -461,7 +461,7 @@ macro_rules! int_impl {
}
/// Checked integer remainder. Computes `self % rhs`, returning `None`
- /// if `rhs == 0` or the operation results in overflow.
+ /// if `rhs == 0` or the division results in overflow.
///
/// # Examples
///
@@ -1607,7 +1607,7 @@ macro_rules! uint_impl {
}
/// Checked integer division. Computes `self / rhs`, returning `None`
- /// if `rhs == 0` or the operation results in overflow.
+ /// if `rhs == 0`.
///
/// # Examples
///
@@ -1627,7 +1627,7 @@ macro_rules! uint_impl {
}
/// Checked integer remainder. Computes `self % rhs`, returning `None`
- /// if `rhs == 0` or the operation results in overflow.
+ /// if `rhs == 0`.
///
/// # Examples
///
diff --git a/src/libpanic_abort/lib.rs b/src/libpanic_abort/lib.rs
index 29a9e1aadaf..c3bd6a2bc18 100644
--- a/src/libpanic_abort/lib.rs
+++ b/src/libpanic_abort/lib.rs
@@ -53,7 +53,7 @@ pub unsafe extern fn __rust_maybe_catch_panic(f: fn(*mut u8),
pub unsafe extern fn __rust_start_panic(_data: usize, _vtable: usize) -> u32 {
abort();
- #[cfg(unix)]
+ #[cfg(any(unix, target_os = "cloudabi"))]
unsafe fn abort() -> ! {
extern crate libc;
libc::abort();
diff --git a/src/libpanic_unwind/lib.rs b/src/libpanic_unwind/lib.rs
index 6b8da7a51ce..92e40e8f26d 100644
--- a/src/libpanic_unwind/lib.rs
+++ b/src/libpanic_unwind/lib.rs
@@ -68,6 +68,7 @@ mod imp;
// i686-pc-windows-gnu and all others
#[cfg(any(all(unix, not(target_os = "emscripten")),
+ target_os = "cloudabi",
target_os = "redox",
all(windows, target_arch = "x86", target_env = "gnu")))]
#[path = "gcc.rs"]
diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs
index 57120d61e7c..c31a5c9d86d 100644
--- a/src/librustc/ich/impls_syntax.rs
+++ b/src/librustc/ich/impls_syntax.rs
@@ -155,8 +155,8 @@ impl_stable_hash_for!(enum ::syntax::ast::LitKind {
Bool(value)
});
-impl_stable_hash_for!(enum ::syntax::ast::IntTy { Is, I8, I16, I32, I64, I128 });
-impl_stable_hash_for!(enum ::syntax::ast::UintTy { Us, U8, U16, U32, U64, U128 });
+impl_stable_hash_for!(enum ::syntax::ast::IntTy { Isize, I8, I16, I32, I64, I128 });
+impl_stable_hash_for!(enum ::syntax::ast::UintTy { Usize, U8, U16, U32, U64, U128 });
impl_stable_hash_for!(enum ::syntax::ast::FloatTy { F32, F64 });
impl_stable_hash_for!(enum ::syntax::ast::Unsafety { Unsafe, Normal });
impl_stable_hash_for!(enum ::syntax::ast::Constness { Const, NotConst });
diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs
index 054cb2340ad..8ffea62f6be 100644
--- a/src/librustc/mir/interpret/mod.rs
+++ b/src/librustc/mir/interpret/mod.rs
@@ -145,7 +145,7 @@ impl<'tcx> MemoryPointer {
}
-#[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd, Debug)]
+#[derive(Copy, Clone, Default, Eq, Hash, Ord, PartialEq, PartialOrd, Debug)]
pub struct AllocId(pub u64);
impl fmt::Display for AllocId {
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
index 6ad9bd94bf2..05b1d584e9c 100644
--- a/src/librustc/session/config.rs
+++ b/src/librustc/session/config.rs
@@ -1082,6 +1082,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
"gather borrowck statistics"),
no_landing_pads: bool = (false, parse_bool, [TRACKED],
"omit landing pads for unwinding"),
+ fewer_names: bool = (false, parse_bool, [TRACKED],
+ "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR)"),
debug_llvm: bool = (false, parse_bool, [UNTRACKED],
"enable debug output from LLVM"),
meta_stats: bool = (false, parse_bool, [UNTRACKED],
@@ -2811,6 +2813,10 @@ mod tests {
opts.debugging_opts.no_landing_pads = true;
assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
+ opts = reference.clone();
+ opts.debugging_opts.fewer_names = true;
+ assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
+
opts = reference.clone();
opts.debugging_opts.no_trans = true;
assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index 19fbbe10be9..43dbb8d7e13 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -18,7 +18,7 @@ use lint;
use middle::allocator::AllocatorKind;
use middle::dependency_format;
use session::search_paths::PathKind;
-use session::config::{BorrowckMode, DebugInfoLevel};
+use session::config::{BorrowckMode, DebugInfoLevel, OutputType};
use ty::tls;
use util::nodemap::{FxHashMap, FxHashSet};
use util::common::{duration_to_secs_str, ErrorReported};
@@ -504,6 +504,13 @@ impl Session {
pub fn linker_flavor(&self) -> LinkerFlavor {
self.opts.debugging_opts.linker_flavor.unwrap_or(self.target.target.linker_flavor)
}
+
+ pub fn fewer_names(&self) -> bool {
+ let more_names = self.opts.output_types.contains_key(&OutputType::LlvmAssembly) ||
+ self.opts.output_types.contains_key(&OutputType::Bitcode);
+ self.opts.debugging_opts.fewer_names || !more_names
+ }
+
pub fn no_landing_pads(&self) -> bool {
self.opts.debugging_opts.no_landing_pads || self.panic_strategy() == PanicStrategy::Abort
}
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index e21eb8bbf8a..87742fe9162 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -754,13 +754,13 @@ impl<'tcx> CommonTypes<'tcx> {
char: mk(TyChar),
never: mk(TyNever),
err: mk(TyError),
- isize: mk(TyInt(ast::IntTy::Is)),
+ isize: mk(TyInt(ast::IntTy::Isize)),
i8: mk(TyInt(ast::IntTy::I8)),
i16: mk(TyInt(ast::IntTy::I16)),
i32: mk(TyInt(ast::IntTy::I32)),
i64: mk(TyInt(ast::IntTy::I64)),
i128: mk(TyInt(ast::IntTy::I128)),
- usize: mk(TyUint(ast::UintTy::Us)),
+ usize: mk(TyUint(ast::UintTy::Usize)),
u8: mk(TyUint(ast::UintTy::U8)),
u16: mk(TyUint(ast::UintTy::U16)),
u32: mk(TyUint(ast::UintTy::U32)),
@@ -895,31 +895,29 @@ pub struct InterpretInterner<'tcx> {
allocs: FxHashSet<&'tcx interpret::Allocation>,
/// Allows obtaining function instance handles via a unique identifier
- functions: FxHashMap<u64, Instance<'tcx>>,
+ functions: FxHashMap<interpret::AllocId, Instance<'tcx>>,
/// Inverse map of `interpret_functions`.
/// Used so we don't allocate a new pointer every time we need one
- function_cache: FxHashMap<Instance<'tcx>, u64>,
+ function_cache: FxHashMap<Instance<'tcx>, interpret::AllocId>,
/// Allows obtaining const allocs via a unique identifier
- alloc_by_id: FxHashMap<u64, &'tcx interpret::Allocation>,
+ alloc_by_id: FxHashMap<interpret::AllocId, &'tcx interpret::Allocation>,
/// The AllocId to assign to the next new regular allocation.
/// Always incremented, never gets smaller.
- next_id: u64,
+ next_id: interpret::AllocId,
/// Allows checking whether a constant already has an allocation
- ///
- /// The pointers are to the beginning of an `alloc_by_id` allocation
- alloc_cache: FxHashMap<interpret::GlobalId<'tcx>, interpret::Pointer>,
+ alloc_cache: FxHashMap<interpret::GlobalId<'tcx>, interpret::AllocId>,
/// A cache for basic byte allocations keyed by their contents. This is used to deduplicate
/// allocations for string and bytestring literals.
- literal_alloc_cache: FxHashMap<Vec<u8>, u64>,
+ literal_alloc_cache: FxHashMap<Vec<u8>, interpret::AllocId>,
}
impl<'tcx> InterpretInterner<'tcx> {
- pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> u64 {
+ pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> interpret::AllocId {
if let Some(&alloc_id) = self.function_cache.get(&instance) {
return alloc_id;
}
@@ -932,14 +930,14 @@ impl<'tcx> InterpretInterner<'tcx> {
pub fn get_fn(
&self,
- id: u64,
+ id: interpret::AllocId,
) -> Option<Instance<'tcx>> {
self.functions.get(&id).cloned()
}
pub fn get_alloc(
&self,
- id: u64,
+ id: interpret::AllocId,
) -> Option<&'tcx interpret::Allocation> {
self.alloc_by_id.get(&id).cloned()
}
@@ -947,14 +945,14 @@ impl<'tcx> InterpretInterner<'tcx> {
pub fn get_cached(
&self,
global_id: interpret::GlobalId<'tcx>,
- ) -> Option<interpret::Pointer> {
+ ) -> Option<interpret::AllocId> {
self.alloc_cache.get(&global_id).cloned()
}
pub fn cache(
&mut self,
global_id: interpret::GlobalId<'tcx>,
- ptr: interpret::Pointer,
+ ptr: interpret::AllocId,
) {
if let Some(old) = self.alloc_cache.insert(global_id, ptr) {
bug!("tried to cache {:?}, but was already existing as {:#?}", global_id, old);
@@ -963,7 +961,7 @@ impl<'tcx> InterpretInterner<'tcx> {
pub fn intern_at_reserved(
&mut self,
- id: u64,
+ id: interpret::AllocId,
alloc: &'tcx interpret::Allocation,
) {
if let Some(old) = self.alloc_by_id.insert(id, alloc) {
@@ -975,9 +973,9 @@ impl<'tcx> InterpretInterner<'tcx> {
/// yet have an allocation backing it.
pub fn reserve(
&mut self,
- ) -> u64 {
+ ) -> interpret::AllocId {
let next = self.next_id;
- self.next_id = self.next_id
+ self.next_id.0 = self.next_id.0
.checked_add(1)
.expect("You overflowed a u64 by incrementing by 1... \
You've just earned yourself a free drink if we ever meet. \
@@ -1069,7 +1067,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
}
/// Allocates a byte or string literal for `mir::interpret`
- pub fn allocate_cached(self, bytes: &[u8]) -> u64 {
+ pub fn allocate_cached(self, bytes: &[u8]) -> interpret::AllocId {
// check whether we already allocated this literal or a constant with the same memory
if let Some(&alloc_id) = self.interpret_interner.borrow().literal_alloc_cache.get(bytes) {
return alloc_id;
@@ -1912,7 +1910,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
pub fn mk_mach_int(self, tm: ast::IntTy) -> Ty<'tcx> {
match tm {
- ast::IntTy::Is => self.types.isize,
+ ast::IntTy::Isize => self.types.isize,
ast::IntTy::I8 => self.types.i8,
ast::IntTy::I16 => self.types.i16,
ast::IntTy::I32 => self.types.i32,
@@ -1923,7 +1921,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
pub fn mk_mach_uint(self, tm: ast::UintTy) -> Ty<'tcx> {
match tm {
- ast::UintTy::Us => self.types.usize,
+ ast::UintTy::Usize => self.types.usize,
ast::UintTy::U8 => self.types.u8,
ast::UintTy::U16 => self.types.u16,
ast::UintTy::U32 => self.types.u32,
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
index 2a8c259dff8..34a7d4ad7cf 100644
--- a/src/librustc/ty/layout.rs
+++ b/src/librustc/ty/layout.rs
@@ -520,7 +520,7 @@ impl<'a, 'tcx> Integer {
attr::SignedInt(IntTy::I32) | attr::UnsignedInt(UintTy::U32) => I32,
attr::SignedInt(IntTy::I64) | attr::UnsignedInt(UintTy::U64) => I64,
attr::SignedInt(IntTy::I128) | attr::UnsignedInt(UintTy::U128) => I128,
- attr::SignedInt(IntTy::Is) | attr::UnsignedInt(UintTy::Us) => {
+ attr::SignedInt(IntTy::Isize) | attr::UnsignedInt(UintTy::Usize) => {
dl.ptr_sized_integer()
}
}
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 2cea8c01cdf..e5f6ac88530 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -1575,7 +1575,7 @@ impl ReprOptions {
pub fn linear(&self) -> bool { self.flags.contains(ReprFlags::IS_LINEAR) }
pub fn discr_type(&self) -> attr::IntType {
- self.int.unwrap_or(attr::SignedInt(ast::IntTy::Is))
+ self.int.unwrap_or(attr::SignedInt(ast::IntTy::Isize))
}
/// Returns true if this `#[repr()]` should inhabit "smart enum
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
index 433c72f4b2c..cf784b7cafb 100644
--- a/src/librustc/ty/sty.rs
+++ b/src/librustc/ty/sty.rs
@@ -1478,13 +1478,6 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
}
}
- pub fn is_uint(&self) -> bool {
- match self.sty {
- TyInfer(IntVar(_)) | TyUint(ast::UintTy::Us) => true,
- _ => false
- }
- }
-
pub fn is_char(&self) -> bool {
match self.sty {
TyChar => true,
@@ -1512,7 +1505,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
pub fn is_machine(&self) -> bool {
match self.sty {
- TyInt(ast::IntTy::Is) | TyUint(ast::UintTy::Us) => false,
+ TyInt(ast::IntTy::Isize) | TyUint(ast::UintTy::Usize) => false,
TyInt(..) | TyUint(..) | TyFloat(..) => true,
_ => false,
}
diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
index 85052052b32..638859af0f7 100644
--- a/src/librustc/ty/util.rs
+++ b/src/librustc/ty/util.rs
@@ -55,7 +55,7 @@ macro_rules! typed_literal {
SignedInt(ast::IntTy::I32) => ConstInt::I32($lit),
SignedInt(ast::IntTy::I64) => ConstInt::I64($lit),
SignedInt(ast::IntTy::I128) => ConstInt::I128($lit),
- SignedInt(ast::IntTy::Is) => match $tcx.sess.target.isize_ty {
+ SignedInt(ast::IntTy::Isize) => match $tcx.sess.target.isize_ty {
ast::IntTy::I16 => ConstInt::Isize(ConstIsize::Is16($lit)),
ast::IntTy::I32 => ConstInt::Isize(ConstIsize::Is32($lit)),
ast::IntTy::I64 => ConstInt::Isize(ConstIsize::Is64($lit)),
@@ -66,7 +66,7 @@ macro_rules! typed_literal {
UnsignedInt(ast::UintTy::U32) => ConstInt::U32($lit),
UnsignedInt(ast::UintTy::U64) => ConstInt::U64($lit),
UnsignedInt(ast::UintTy::U128) => ConstInt::U128($lit),
- UnsignedInt(ast::UintTy::Us) => match $tcx.sess.target.usize_ty {
+ UnsignedInt(ast::UintTy::Usize) => match $tcx.sess.target.usize_ty {
ast::UintTy::U16 => ConstInt::Usize(ConstUsize::Us16($lit)),
ast::UintTy::U32 => ConstInt::Usize(ConstUsize::Us32($lit)),
ast::UintTy::U64 => ConstInt::Usize(ConstUsize::Us64($lit)),
@@ -84,13 +84,13 @@ impl IntTypeExt for attr::IntType {
SignedInt(ast::IntTy::I32) => tcx.types.i32,
SignedInt(ast::IntTy::I64) => tcx.types.i64,
SignedInt(ast::IntTy::I128) => tcx.types.i128,
- SignedInt(ast::IntTy::Is) => tcx.types.isize,
+ SignedInt(ast::IntTy::Isize) => tcx.types.isize,
UnsignedInt(ast::UintTy::U8) => tcx.types.u8,
UnsignedInt(ast::UintTy::U16) => tcx.types.u16,
UnsignedInt(ast::UintTy::U32) => tcx.types.u32,
UnsignedInt(ast::UintTy::U64) => tcx.types.u64,
UnsignedInt(ast::UintTy::U128) => tcx.types.u128,
- UnsignedInt(ast::UintTy::Us) => tcx.types.usize,
+ UnsignedInt(ast::UintTy::Usize) => tcx.types.usize,
}
}
@@ -105,13 +105,13 @@ impl IntTypeExt for attr::IntType {
(SignedInt(ast::IntTy::I32), ConstInt::I32(_)) => {},
(SignedInt(ast::IntTy::I64), ConstInt::I64(_)) => {},
(SignedInt(ast::IntTy::I128), ConstInt::I128(_)) => {},
- (SignedInt(ast::IntTy::Is), ConstInt::Isize(_)) => {},
+ (SignedInt(ast::IntTy::Isize), ConstInt::Isize(_)) => {},
(UnsignedInt(ast::UintTy::U8), ConstInt::U8(_)) => {},
(UnsignedInt(ast::UintTy::U16), ConstInt::U16(_)) => {},
(UnsignedInt(ast::UintTy::U32), ConstInt::U32(_)) => {},
(UnsignedInt(ast::UintTy::U64), ConstInt::U64(_)) => {},
(UnsignedInt(ast::UintTy::U128), ConstInt::U128(_)) => {},
- (UnsignedInt(ast::UintTy::Us), ConstInt::Usize(_)) => {},
+ (UnsignedInt(ast::UintTy::Usize), ConstInt::Usize(_)) => {},
_ => bug!("disr type mismatch: {:?} vs {:?}", self, val),
}
}
diff --git a/src/librustc_const_eval/eval.rs b/src/librustc_const_eval/eval.rs
index 81cd63b5407..418bd4b5eff 100644
--- a/src/librustc_const_eval/eval.rs
+++ b/src/librustc_const_eval/eval.rs
@@ -133,8 +133,8 @@ fn eval_const_expr_partial<'a, 'tcx>(cx: &ConstContext<'a, 'tcx>,
(&LitKind::Int(I128_OVERFLOW, Signed(IntTy::I128)), _) => {
Some(I128(i128::min_value()))
},
- (&LitKind::Int(n, _), &ty::TyInt(IntTy::Is)) |
- (&LitKind::Int(n, Signed(IntTy::Is)), _) => {
+ (&LitKind::Int(n, _), &ty::TyInt(IntTy::Isize)) |
+ (&LitKind::Int(n, Signed(IntTy::Isize)), _) => {
match tcx.sess.target.isize_ty {
IntTy::I16 => if n == I16_OVERFLOW {
Some(Isize(Is16(i16::min_value())))
@@ -478,7 +478,7 @@ fn cast_const_int<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
ty::TyInt(ast::IntTy::I32) => Ok(Integral(I32(v as i128 as i32))),
ty::TyInt(ast::IntTy::I64) => Ok(Integral(I64(v as i128 as i64))),
ty::TyInt(ast::IntTy::I128) => Ok(Integral(I128(v as i128))),
- ty::TyInt(ast::IntTy::Is) => {
+ ty::TyInt(ast::IntTy::Isize) => {
Ok(Integral(Isize(ConstIsize::new_truncating(v as i128, tcx.sess.target.isize_ty))))
},
ty::TyUint(ast::UintTy::U8) => Ok(Integral(U8(v as u8))),
@@ -486,7 +486,7 @@ fn cast_const_int<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
ty::TyUint(ast::UintTy::U32) => Ok(Integral(U32(v as u32))),
ty::TyUint(ast::UintTy::U64) => Ok(Integral(U64(v as u64))),
ty::TyUint(ast::UintTy::U128) => Ok(Integral(U128(v as u128))),
- ty::TyUint(ast::UintTy::Us) => {
+ ty::TyUint(ast::UintTy::Usize) => {
Ok(Integral(Usize(ConstUsize::new_truncating(v, tcx.sess.target.usize_ty))))
},
ty::TyFloat(fty) => {
diff --git a/src/librustc_const_math/err.rs b/src/librustc_const_math/err.rs
index 1e9c2badd68..bd0a332436e 100644
--- a/src/librustc_const_math/err.rs
+++ b/src/librustc_const_math/err.rs
@@ -75,13 +75,13 @@ impl ConstMathErr {
ULitOutOfRange(ast::UintTy::U32) => "literal out of range for u32",
ULitOutOfRange(ast::UintTy::U64) => "literal out of range for u64",
ULitOutOfRange(ast::UintTy::U128) => "literal out of range for u128",
- ULitOutOfRange(ast::UintTy::Us) => "literal out of range for usize",
+ ULitOutOfRange(ast::UintTy::Usize) => "literal out of range for usize",
LitOutOfRange(ast::IntTy::I8) => "literal out of range for i8",
LitOutOfRange(ast::IntTy::I16) => "literal out of range for i16",
LitOutOfRange(ast::IntTy::I32) => "literal out of range for i32",
LitOutOfRange(ast::IntTy::I64) => "literal out of range for i64",
LitOutOfRange(ast::IntTy::I128) => "literal out of range for i128",
- LitOutOfRange(ast::IntTy::Is) => "literal out of range for isize",
+ LitOutOfRange(ast::IntTy::Isize) => "literal out of range for isize",
}
}
}
diff --git a/src/librustc_const_math/int.rs b/src/librustc_const_math/int.rs
index 08473d729e4..4ec27d7ade5 100644
--- a/src/librustc_const_math/int.rs
+++ b/src/librustc_const_math/int.rs
@@ -12,8 +12,8 @@ use std::cmp::Ordering;
use syntax::attr::IntType;
use syntax::ast::{IntTy, UintTy};
-use super::is::*;
-use super::us::*;
+use super::isize::*;
+use super::usize::*;
use super::err::*;
#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, Hash, Eq, PartialEq)]
@@ -83,7 +83,7 @@ impl ConstInt {
UintTy::U16 if val <= ubounds::U16MAX => Some(U16(val as u16)),
UintTy::U32 if val <= ubounds::U32MAX => Some(U32(val as u32)),
UintTy::U64 if val <= ubounds::U64MAX => Some(U64(val as u64)),
- UintTy::Us if val <= ubounds::U64MAX => ConstUsize::new(val as u64, usize_ty).ok()
+ UintTy::Usize if val <= ubounds::U64MAX => ConstUsize::new(val as u64, usize_ty).ok()
.map(Usize),
UintTy::U128 => Some(U128(val)),
_ => None
@@ -98,7 +98,7 @@ impl ConstInt {
IntTy::I16 if val <= ibounds::I16MAX => Some(I16(val as i16)),
IntTy::I32 if val <= ibounds::I32MAX => Some(I32(val as i32)),
IntTy::I64 if val <= ibounds::I64MAX => Some(I64(val as i64)),
- IntTy::Is if val <= ibounds::I64MAX => ConstIsize::new(val as i64, isize_ty).ok()
+ IntTy::Isize if val <= ibounds::I64MAX => ConstIsize::new(val as i64, isize_ty).ok()
.map(Isize),
IntTy::I128 => Some(I128(val)),
_ => None
@@ -112,7 +112,7 @@ impl ConstInt {
UintTy::U16 => U16(val as u16),
UintTy::U32 => U32(val as u32),
UintTy::U64 => U64(val as u64),
- UintTy::Us => Usize(ConstUsize::new_truncating(val, usize_ty)),
+ UintTy::Usize => Usize(ConstUsize::new_truncating(val, usize_ty)),
UintTy::U128 => U128(val)
}
}
@@ -124,7 +124,7 @@ impl ConstInt {
IntTy::I16 => I16(val as i16),
IntTy::I32 => I32(val as i32),
IntTy::I64 => I64(val as i64),
- IntTy::Is => Isize(ConstIsize::new_truncating(val, isize_ty)),
+ IntTy::Isize => Isize(ConstIsize::new_truncating(val, isize_ty)),
IntTy::I128 => I128(val)
}
}
@@ -280,13 +280,13 @@ impl ConstInt {
ConstInt::I32(_) => IntType::SignedInt(IntTy::I32),
ConstInt::I64(_) => IntType::SignedInt(IntTy::I64),
ConstInt::I128(_) => IntType::SignedInt(IntTy::I128),
- ConstInt::Isize(_) => IntType::SignedInt(IntTy::Is),
+ ConstInt::Isize(_) => IntType::SignedInt(IntTy::Isize),
ConstInt::U8(_) => IntType::UnsignedInt(UintTy::U8),
ConstInt::U16(_) => IntType::UnsignedInt(UintTy::U16),
ConstInt::U32(_) => IntType::UnsignedInt(UintTy::U32),
ConstInt::U64(_) => IntType::UnsignedInt(UintTy::U64),
ConstInt::U128(_) => IntType::UnsignedInt(UintTy::U128),
- ConstInt::Usize(_) => IntType::UnsignedInt(UintTy::Us),
+ ConstInt::Usize(_) => IntType::UnsignedInt(UintTy::Usize),
}
}
}
diff --git a/src/librustc_const_math/is.rs b/src/librustc_const_math/isize.rs
similarity index 92%
rename from src/librustc_const_math/is.rs
rename to src/librustc_const_math/isize.rs
index 50dfb601129..18acc782775 100644
--- a/src/librustc_const_math/is.rs
+++ b/src/librustc_const_math/isize.rs
@@ -38,9 +38,9 @@ impl ConstIsize {
pub fn new(i: i64, isize_ty: ast::IntTy) -> Result<Self, ConstMathErr> {
match isize_ty {
ast::IntTy::I16 if i as i16 as i64 == i => Ok(Is16(i as i16)),
- ast::IntTy::I16 => Err(LitOutOfRange(ast::IntTy::Is)),
+ ast::IntTy::I16 => Err(LitOutOfRange(ast::IntTy::Isize)),
ast::IntTy::I32 if i as i32 as i64 == i => Ok(Is32(i as i32)),
- ast::IntTy::I32 => Err(LitOutOfRange(ast::IntTy::Is)),
+ ast::IntTy::I32 => Err(LitOutOfRange(ast::IntTy::Isize)),
ast::IntTy::I64 => Ok(Is64(i)),
_ => unreachable!(),
}
diff --git a/src/librustc_const_math/lib.rs b/src/librustc_const_math/lib.rs
index 095b8bb50dc..2d98bc48d28 100644
--- a/src/librustc_const_math/lib.rs
+++ b/src/librustc_const_math/lib.rs
@@ -30,12 +30,12 @@ extern crate serialize as rustc_serialize; // used by deriving
mod float;
mod int;
-mod us;
-mod is;
+mod usize;
+mod isize;
mod err;
pub use float::*;
pub use int::*;
-pub use us::*;
-pub use is::*;
+pub use usize::*;
+pub use isize::*;
pub use err::{ConstMathErr, Op};
diff --git a/src/librustc_const_math/us.rs b/src/librustc_const_math/usize.rs
similarity index 99%
rename from src/librustc_const_math/us.rs
rename to src/librustc_const_math/usize.rs
index 9876bc4d779..56995f08f05 100644
--- a/src/librustc_const_math/us.rs
+++ b/src/librustc_const_math/usize.rs
@@ -38,9 +38,9 @@ impl ConstUsize {
pub fn new(i: u64, usize_ty: ast::UintTy) -> Result<Self, ConstMathErr> {
match usize_ty {
ast::UintTy::U16 if i as u16 as u64 == i => Ok(Us16(i as u16)),
- ast::UintTy::U16 => Err(ULitOutOfRange(ast::UintTy::Us)),
+ ast::UintTy::U16 => Err(ULitOutOfRange(ast::UintTy::Usize)),
ast::UintTy::U32 if i as u32 as u64 == i => Ok(Us32(i as u32)),
- ast::UintTy::U32 => Err(ULitOutOfRange(ast::UintTy::Us)),
+ ast::UintTy::U32 => Err(ULitOutOfRange(ast::UintTy::Usize)),
ast::UintTy::U64 => Ok(Us64(i)),
_ => unreachable!(),
}
diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs
index c109a47f798..5456b0d252b 100644
--- a/src/librustc_lint/types.rs
+++ b/src/librustc_lint/types.rs
@@ -140,7 +140,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {
match lit.node {
ast::LitKind::Int(v, ast::LitIntType::Signed(_)) |
ast::LitKind::Int(v, ast::LitIntType::Unsuffixed) => {
- let int_type = if let ast::IntTy::Is = t {
+ let int_type = if let ast::IntTy::Isize = t {
cx.sess().target.isize_ty
} else {
t
@@ -163,7 +163,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {
};
}
ty::TyUint(t) => {
- let uint_type = if let ast::UintTy::Us = t {
+ let uint_type = if let ast::UintTy::Usize = t {
cx.sess().target.usize_ty
} else {
t
@@ -230,7 +230,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {
// warnings are consistent between 32- and 64-bit platforms
fn int_ty_range(int_ty: ast::IntTy) -> (i128, i128) {
match int_ty {
- ast::IntTy::Is => (i64::min_value() as i128, i64::max_value() as i128),
+ ast::IntTy::Isize => (i64::min_value() as i128, i64::max_value() as i128),
ast::IntTy::I8 => (i8::min_value() as i64 as i128, i8::max_value() as i128),
ast::IntTy::I16 => (i16::min_value() as i64 as i128, i16::max_value() as i128),
ast::IntTy::I32 => (i32::min_value() as i64 as i128, i32::max_value() as i128),
@@ -241,7 +241,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {
fn uint_ty_range(uint_ty: ast::UintTy) -> (u128, u128) {
match uint_ty {
- ast::UintTy::Us => (u64::min_value() as u128, u64::max_value() as u128),
+ ast::UintTy::Usize => (u64::min_value() as u128, u64::max_value() as u128),
ast::UintTy::U8 => (u8::min_value() as u128, u8::max_value() as u128),
ast::UintTy::U16 => (u16::min_value() as u128, u16::max_value() as u128),
ast::UintTy::U32 => (u32::min_value() as u128, u32::max_value() as u128),
@@ -252,7 +252,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {
fn int_ty_bits(int_ty: ast::IntTy, isize_ty: ast::IntTy) -> u64 {
match int_ty {
- ast::IntTy::Is => int_ty_bits(isize_ty, isize_ty),
+ ast::IntTy::Isize => int_ty_bits(isize_ty, isize_ty),
ast::IntTy::I8 => 8,
ast::IntTy::I16 => 16 as u64,
ast::IntTy::I32 => 32,
@@ -263,7 +263,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits {
fn uint_ty_bits(uint_ty: ast::UintTy, usize_ty: ast::UintTy) -> u64 {
match uint_ty {
- ast::UintTy::Us => uint_ty_bits(usize_ty, usize_ty),
+ ast::UintTy::Usize => uint_ty_bits(usize_ty, usize_ty),
ast::UintTy::U8 => 8,
ast::UintTy::U16 => 16,
ast::UintTy::U32 => 32,
@@ -387,7 +387,7 @@ fn is_ffi_safe(ty: attr::IntType) -> bool {
attr::SignedInt(ast::IntTy::I32) | attr::UnsignedInt(ast::UintTy::U32) |
attr::SignedInt(ast::IntTy::I64) | attr::UnsignedInt(ast::UintTy::U64) |
attr::SignedInt(ast::IntTy::I128) | attr::UnsignedInt(ast::UintTy::U128) => true,
- attr::SignedInt(ast::IntTy::Is) | attr::UnsignedInt(ast::UintTy::Us) => false
+ attr::SignedInt(ast::IntTy::Isize) | attr::UnsignedInt(ast::UintTy::Usize) => false
}
}
diff --git a/src/librustc_llvm/ffi.rs b/src/librustc_llvm/ffi.rs
index 4e651956265..6cb1a2b5334 100644
--- a/src/librustc_llvm/ffi.rs
+++ b/src/librustc_llvm/ffi.rs
@@ -514,7 +514,7 @@ pub enum ModuleBuffer {}
#[link(name = "rustllvm", kind = "static")]
extern "C" {
// Create and destroy contexts.
- pub fn LLVMContextCreate() -> ContextRef;
+ pub fn LLVMRustContextCreate(shouldDiscardNames: bool) -> ContextRef;
pub fn LLVMContextDispose(C: ContextRef);
pub fn LLVMGetMDKindIDInContext(C: ContextRef, Name: *const c_char, SLen: c_uint) -> c_uint;
diff --git a/src/librustc_mir/build/expr/as_rvalue.rs b/src/librustc_mir/build/expr/as_rvalue.rs
index ee0b7bb7a8b..d3cc9527590 100644
--- a/src/librustc_mir/build/expr/as_rvalue.rs
+++ b/src/librustc_mir/build/expr/as_rvalue.rs
@@ -392,7 +392,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
ast::IntTy::I32 => ConstInt::I32(-1),
ast::IntTy::I64 => ConstInt::I64(-1),
ast::IntTy::I128 => ConstInt::I128(-1),
- ast::IntTy::Is => {
+ ast::IntTy::Isize => {
let int_ty = self.hir.tcx().sess.target.isize_ty;
let val = ConstIsize::new(-1, int_ty).unwrap();
ConstInt::Isize(val)
@@ -424,7 +424,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
ast::IntTy::I32 => ConstInt::I32(i32::min_value()),
ast::IntTy::I64 => ConstInt::I64(i64::min_value()),
ast::IntTy::I128 => ConstInt::I128(i128::min_value()),
- ast::IntTy::Is => {
+ ast::IntTy::Isize => {
let int_ty = self.hir.tcx().sess.target.isize_ty;
let min = match int_ty {
ast::IntTy::I16 => std::i16::MIN as i64,
diff --git a/src/librustc_mir/build/misc.rs b/src/librustc_mir/build/misc.rs
index 8486c63baac..a3350cb1671 100644
--- a/src/librustc_mir/build/misc.rs
+++ b/src/librustc_mir/build/misc.rs
@@ -74,7 +74,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
ast::UintTy::U32 => ConstInt::U32(0),
ast::UintTy::U64 => ConstInt::U64(0),
ast::UintTy::U128 => ConstInt::U128(0),
- ast::UintTy::Us => {
+ ast::UintTy::Usize => {
let uint_ty = self.hir.tcx().sess.target.usize_ty;
let val = ConstUsize::new(0, uint_ty).unwrap();
ConstInt::Usize(val)
@@ -95,7 +95,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
ast::IntTy::I32 => ConstInt::I32(0),
ast::IntTy::I64 => ConstInt::I64(0),
ast::IntTy::I128 => ConstInt::I128(0),
- ast::IntTy::Is => {
+ ast::IntTy::Isize => {
let int_ty = self.hir.tcx().sess.target.isize_ty;
let val = ConstIsize::new(0, int_ty).unwrap();
ConstInt::Isize(val)
diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs
index 6f4a28fb28f..b476ea56852 100644
--- a/src/librustc_mir/interpret/cast.rs
+++ b/src/librustc_mir/interpret/cast.rs
@@ -49,7 +49,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
IntTy::I32 => v as i32 as u128,
IntTy::I64 => v as i64 as u128,
IntTy::I128 => v as u128,
- IntTy::Is => {
+ IntTy::Isize => {
let ty = self.tcx.sess.target.isize_ty;
self.int_to_int(v, ty)
}
@@ -62,7 +62,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
UintTy::U32 => v as u32 as u128,
UintTy::U64 => v as u64 as u128,
UintTy::U128 => v,
- UintTy::Us => {
+ UintTy::Usize => {
let ty = self.tcx.sess.target.usize_ty;
self.int_to_uint(v, ty)
}
@@ -124,8 +124,8 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
match ty.sty {
// Casting to a reference or fn pointer is not permitted by rustc, no need to support it here.
TyRawPtr(_) |
- TyInt(IntTy::Is) |
- TyUint(UintTy::Us) => Ok(PrimVal::Ptr(ptr)),
+ TyInt(IntTy::Isize) |
+ TyUint(UintTy::Usize) => Ok(PrimVal::Ptr(ptr)),
TyInt(_) | TyUint(_) => err!(ReadPointerAsBytes),
_ => err!(Unimplemented(format!("ptr to {:?} cast", ty))),
}
diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs
index a37cf41baab..ef27c636ce0 100644
--- a/src/librustc_mir/interpret/const_eval.rs
+++ b/src/librustc_mir/interpret/const_eval.rs
@@ -12,7 +12,7 @@ use rustc_data_structures::indexed_vec::Idx;
use syntax::ast::Mutability;
use syntax::codemap::Span;
-use rustc::mir::interpret::{EvalResult, EvalError, EvalErrorKind, GlobalId, Value, Pointer, PrimVal};
+use rustc::mir::interpret::{EvalResult, EvalError, EvalErrorKind, GlobalId, Value, MemoryPointer, Pointer, PrimVal};
use super::{Place, EvalContext, StackPopCleanup, ValTy};
use rustc_const_math::ConstInt;
@@ -67,7 +67,7 @@ pub fn eval_body<'a, 'tcx>(
layout.align,
None,
)?;
- tcx.interpret_interner.borrow_mut().cache(cid, ptr.into());
+ tcx.interpret_interner.borrow_mut().cache(cid, ptr.alloc_id);
let cleanup = StackPopCleanup::MarkStatic(Mutability::Immutable);
let name = ty::tls::with(|tcx| tcx.item_path_str(instance.def_id()));
trace!("const_eval: pushing stack frame for global: {}", name);
@@ -81,8 +81,8 @@ pub fn eval_body<'a, 'tcx>(
while ecx.step()? {}
}
- let value = tcx.interpret_interner.borrow().get_cached(cid).expect("global not cached");
- Ok((value, instance_ty))
+ let alloc = tcx.interpret_interner.borrow().get_cached(cid).expect("global not cached");
+ Ok((MemoryPointer::new(alloc, 0).into(), instance_ty))
}
pub fn eval_body_as_integer<'a, 'tcx>(
@@ -106,7 +106,7 @@ pub fn eval_body_as_integer<'a, 'tcx>(
TyInt(IntTy::I32) => ConstInt::I32(prim as i128 as i32),
TyInt(IntTy::I64) => ConstInt::I64(prim as i128 as i64),
TyInt(IntTy::I128) => ConstInt::I128(prim as i128),
- TyInt(IntTy::Is) => ConstInt::Isize(
+ TyInt(IntTy::Isize) => ConstInt::Isize(
ConstIsize::new(prim as i128 as i64, tcx.sess.target.isize_ty)
.expect("miri should already have errored"),
),
@@ -115,7 +115,7 @@ pub fn eval_body_as_integer<'a, 'tcx>(
TyUint(UintTy::U32) => ConstInt::U32(prim as u32),
TyUint(UintTy::U64) => ConstInt::U64(prim as u64),
TyUint(UintTy::U128) => ConstInt::U128(prim),
- TyUint(UintTy::Us) => ConstInt::Usize(
+ TyUint(UintTy::Usize) => ConstInt::Usize(
ConstUsize::new(prim as u64, tcx.sess.target.usize_ty)
.expect("miri should already have errored"),
),
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 89d0e91a7ec..3af914a6c13 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -950,8 +950,8 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
}
pub fn read_global_as_value(&self, gid: GlobalId, layout: TyLayout) -> Value {
- Value::ByRef(self.tcx.interpret_interner.borrow().get_cached(gid).expect("global not cached"),
- layout.align)
+ let alloc = self.tcx.interpret_interner.borrow().get_cached(gid).expect("global not cached");
+ Value::ByRef(MemoryPointer::new(alloc, 0).into(), layout.align)
}
pub fn force_allocation(&mut self, place: Place) -> EvalResult<'tcx, Place> {
@@ -1165,7 +1165,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
I32 => 4,
I64 => 8,
I128 => 16,
- Is => self.memory.pointer_size(),
+ Isize => self.memory.pointer_size(),
};
PrimValKind::from_int_size(size)
}
@@ -1178,7 +1178,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
U32 => 4,
U64 => 8,
U128 => 16,
- Us => self.memory.pointer_size(),
+ Usize => self.memory.pointer_size(),
};
PrimValKind::from_uint_size(size)
}
@@ -1292,7 +1292,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
I32 => 4,
I64 => 8,
I128 => 16,
- Is => self.memory.pointer_size(),
+ Isize => self.memory.pointer_size(),
};
self.memory.read_primval(ptr, ptr_align, size, true)?
}
@@ -1305,7 +1305,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
U32 => 4,
U64 => 8,
U128 => 16,
- Us => self.memory.pointer_size(),
+ Usize => self.memory.pointer_size(),
};
self.memory.read_primval(ptr, ptr_align, size, false)?
}
diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs
index 47a6bfeb37b..c2989dbaaf1 100644
--- a/src/librustc_mir/interpret/machine.rs
+++ b/src/librustc_mir/interpret/machine.rs
@@ -2,7 +2,7 @@
//! This separation exists to ensure that no fancy miri features like
//! interpreting common C functions leak into CTFE.
-use rustc::mir::interpret::{EvalResult, PrimVal, MemoryPointer, AccessKind};
+use rustc::mir::interpret::{AllocId, EvalResult, PrimVal, MemoryPointer, AccessKind};
use super::{EvalContext, Place, ValTy, Memory};
use rustc::mir;
@@ -89,12 +89,12 @@ pub trait Machine<'tcx>: Sized {
fn add_lock<'a>(
_mem: &mut Memory<'a, 'tcx, Self>,
- _id: u64,
+ _id: AllocId,
) {}
fn free_lock<'a>(
_mem: &mut Memory<'a, 'tcx, Self>,
- _id: u64,
+ _id: AllocId,
_len: u64,
) -> EvalResult<'tcx> {
Ok(())
diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
index 671fe29c0e1..3a28eae2d1c 100644
--- a/src/librustc_mir/interpret/memory.rs
+++ b/src/librustc_mir/interpret/memory.rs
@@ -34,15 +34,15 @@ pub struct Memory<'a, 'tcx: 'a, M: Machine<'tcx>> {
pub data: M::MemoryData,
/// Helps guarantee that stack allocations aren't deallocated via `rust_deallocate`
- alloc_kind: HashMap<u64, MemoryKind<M::MemoryKinds>>,
+ alloc_kind: HashMap<AllocId, MemoryKind<M::MemoryKinds>>,
/// Actual memory allocations (arbitrary bytes, may contain pointers into other allocations).
- alloc_map: HashMap<u64, Allocation>,
+ alloc_map: HashMap<AllocId, Allocation>,
/// Actual memory allocations (arbitrary bytes, may contain pointers into other allocations).
///
/// Stores statics while they are being processed, before they are interned and thus frozen
- uninitialized_statics: HashMap<u64, Allocation>,
+ uninitialized_statics: HashMap<AllocId, Allocation>,
/// Number of virtual bytes allocated.
memory_usage: u64,
@@ -73,17 +73,17 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
pub fn allocations<'x>(
&'x self,
) -> impl Iterator<Item = (AllocId, &'x Allocation)> {
- self.alloc_map.iter().map(|(&id, alloc)| (AllocId(id), alloc))
+ self.alloc_map.iter().map(|(&id, alloc)| (id, alloc))
}
pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> MemoryPointer {
let id = self.tcx.interpret_interner.borrow_mut().create_fn_alloc(instance);
- MemoryPointer::new(AllocId(id), 0)
+ MemoryPointer::new(id, 0)
}
pub fn allocate_cached(&mut self, bytes: &[u8]) -> MemoryPointer {
let id = self.tcx.allocate_cached(bytes);
- MemoryPointer::new(AllocId(id), 0)
+ MemoryPointer::new(id, 0)
}
/// kind is `None` for statics
@@ -121,7 +121,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
},
Some(MemoryKind::MutableStatic) => bug!("don't allocate mutable statics directly")
}
- Ok(MemoryPointer::new(AllocId(id), 0))
+ Ok(MemoryPointer::new(id, 0))
}
pub fn reallocate(
@@ -136,8 +136,8 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
if ptr.offset != 0 {
return err!(ReallocateNonBasePtr);
}
- if self.alloc_map.contains_key(&ptr.alloc_id.0) {
- let alloc_kind = self.alloc_kind[&ptr.alloc_id.0];
+ if self.alloc_map.contains_key(&ptr.alloc_id) {
+ let alloc_kind = self.alloc_kind[&ptr.alloc_id];
if alloc_kind != kind {
return err!(ReallocatedWrongMemoryKind(
format!("{:?}", alloc_kind),
@@ -163,7 +163,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
}
pub fn deallocate_local(&mut self, ptr: MemoryPointer) -> EvalResult<'tcx> {
- match self.alloc_kind.get(&ptr.alloc_id.0).cloned() {
+ match self.alloc_kind.get(&ptr.alloc_id).cloned() {
// for a constant like `const FOO: &i32 = &1;` the local containing
// the `1` is referred to by the global. We transitively marked everything
// the global refers to as static itself, so we don't free it here
@@ -185,19 +185,19 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
return err!(DeallocateNonBasePtr);
}
- let alloc = match self.alloc_map.remove(&ptr.alloc_id.0) {
+ let alloc = match self.alloc_map.remove(&ptr.alloc_id) {
Some(alloc) => alloc,
- None => if self.uninitialized_statics.contains_key(&ptr.alloc_id.0) {
+ None => if self.uninitialized_statics.contains_key(&ptr.alloc_id) {
return err!(DeallocatedWrongMemoryKind(
"uninitializedstatic".to_string(),
format!("{:?}", kind),
))
- } else if self.tcx.interpret_interner.borrow().get_fn(ptr.alloc_id.0).is_some() {
+ } else if self.tcx.interpret_interner.borrow().get_fn(ptr.alloc_id).is_some() {
return err!(DeallocatedWrongMemoryKind(
"function".to_string(),
format!("{:?}", kind),
))
- } else if self.tcx.interpret_interner.borrow().get_alloc(ptr.alloc_id.0).is_some() {
+ } else if self.tcx.interpret_interner.borrow().get_alloc(ptr.alloc_id).is_some() {
return err!(DeallocatedWrongMemoryKind(
"static".to_string(),
format!("{:?}", kind),
@@ -207,14 +207,14 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
},
};
- let alloc_kind = self.alloc_kind.remove(&ptr.alloc_id.0).expect("alloc_map out of sync with alloc_kind");
+ let alloc_kind = self.alloc_kind.remove(&ptr.alloc_id).expect("alloc_map out of sync with alloc_kind");
// It is okay for us to still holds locks on deallocation -- for example, we could store data we own
// in a local, and the local could be deallocated (from StorageDead) before the function returns.
// However, we should check *something*. For now, we make sure that there is no conflicting write
// lock by another frame. We *have* to permit deallocation if we hold a read lock.
// TODO: Figure out the exact rules here.
- M::free_lock(self, ptr.alloc_id.0, alloc.bytes.len() as u64)?;
+ M::free_lock(self, ptr.alloc_id, alloc.bytes.len() as u64)?;
if alloc_kind != kind {
return err!(DeallocatedWrongMemoryKind(
@@ -295,17 +295,17 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
pub fn get(&self, id: AllocId) -> EvalResult<'tcx, &Allocation> {
// normal alloc?
- match self.alloc_map.get(&id.0) {
+ match self.alloc_map.get(&id) {
Some(alloc) => Ok(alloc),
// uninitialized static alloc?
- None => match self.uninitialized_statics.get(&id.0) {
+ None => match self.uninitialized_statics.get(&id) {
Some(alloc) => Ok(alloc),
None => {
let int = self.tcx.interpret_interner.borrow();
// static alloc?
- int.get_alloc(id.0)
+ int.get_alloc(id)
// no alloc? produce an error
- .ok_or_else(|| if int.get_fn(id.0).is_some() {
+ .ok_or_else(|| if int.get_fn(id).is_some() {
EvalErrorKind::DerefFunctionPointer.into()
} else {
EvalErrorKind::DanglingPointerDeref.into()
@@ -320,17 +320,17 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
id: AllocId,
) -> EvalResult<'tcx, &mut Allocation> {
// normal alloc?
- match self.alloc_map.get_mut(&id.0) {
+ match self.alloc_map.get_mut(&id) {
Some(alloc) => Ok(alloc),
// uninitialized static alloc?
- None => match self.uninitialized_statics.get_mut(&id.0) {
+ None => match self.uninitialized_statics.get_mut(&id) {
Some(alloc) => Ok(alloc),
None => {
let int = self.tcx.interpret_interner.borrow();
// no alloc or immutable alloc? produce an error
- if int.get_alloc(id.0).is_some() {
+ if int.get_alloc(id).is_some() {
err!(ModifiedConstantMemory)
- } else if int.get_fn(id.0).is_some() {
+ } else if int.get_fn(id).is_some() {
err!(DerefFunctionPointer)
} else {
err!(DanglingPointerDeref)
@@ -348,7 +348,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
self.tcx
.interpret_interner
.borrow()
- .get_fn(ptr.alloc_id.0)
+ .get_fn(ptr.alloc_id)
.ok_or(EvalErrorKind::ExecuteMemory.into())
}
@@ -372,21 +372,21 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
let (alloc, immutable) =
// normal alloc?
- match self.alloc_map.get(&id.0) {
- Some(a) => (a, match self.alloc_kind[&id.0] {
+ match self.alloc_map.get(&id) {
+ Some(a) => (a, match self.alloc_kind[&id] {
MemoryKind::Stack => " (stack)".to_owned(),
MemoryKind::Machine(m) => format!(" ({:?})", m),
MemoryKind::MutableStatic => " (static mut)".to_owned(),
}),
// uninitialized static alloc?
- None => match self.uninitialized_statics.get(&id.0) {
+ None => match self.uninitialized_statics.get(&id) {
Some(a) => (a, " (static in the process of initialization)".to_owned()),
None => {
let int = self.tcx.interpret_interner.borrow();
// static alloc?
- match int.get_alloc(id.0) {
+ match int.get_alloc(id) {
Some(a) => (a, "(immutable)".to_owned()),
- None => if let Some(func) = int.get_fn(id.0) {
+ None => if let Some(func) = int.get_fn(id) {
trace!("{} {}", msg, func);
continue;
} else {
@@ -445,7 +445,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
let leaks: Vec<_> = self.alloc_map
.keys()
.filter_map(|key| if kinds[key] != MemoryKind::MutableStatic {
- Some(AllocId(*key))
+ Some(*key)
} else {
None
})
@@ -528,7 +528,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
alloc: AllocId,
mutability: Mutability,
) -> EvalResult<'tcx> {
- match self.alloc_kind.get(&alloc.0) {
+ match self.alloc_kind.get(&alloc) {
// do not go into immutable statics
None |
// or mutable statics
@@ -550,13 +550,13 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
mutability
);
if mutability == Mutability::Immutable {
- let alloc = self.alloc_map.remove(&alloc_id.0);
- let kind = self.alloc_kind.remove(&alloc_id.0);
+ let alloc = self.alloc_map.remove(&alloc_id);
+ let kind = self.alloc_kind.remove(&alloc_id);
assert_ne!(kind, Some(MemoryKind::MutableStatic));
- let uninit = self.uninitialized_statics.remove(&alloc_id.0);
+ let uninit = self.uninitialized_statics.remove(&alloc_id);
if let Some(alloc) = alloc.or(uninit) {
let alloc = self.tcx.intern_const_alloc(alloc);
- self.tcx.interpret_interner.borrow_mut().intern_at_reserved(alloc_id.0, alloc);
+ self.tcx.interpret_interner.borrow_mut().intern_at_reserved(alloc_id, alloc);
// recurse into inner allocations
for &alloc in alloc.relocations.values() {
self.mark_inner_allocation_initialized(alloc, mutability)?;
@@ -565,17 +565,17 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
return Ok(());
}
// We are marking the static as initialized, so move it out of the uninit map
- if let Some(uninit) = self.uninitialized_statics.remove(&alloc_id.0) {
- self.alloc_map.insert(alloc_id.0, uninit);
+ if let Some(uninit) = self.uninitialized_statics.remove(&alloc_id) {
+ self.alloc_map.insert(alloc_id, uninit);
}
// do not use `self.get_mut(alloc_id)` here, because we might have already marked a
// sub-element or have circular pointers (e.g. `Rc`-cycles)
- let relocations = match self.alloc_map.get_mut(&alloc_id.0) {
+ let relocations = match self.alloc_map.get_mut(&alloc_id) {
Some(&mut Allocation {
ref mut relocations,
..
}) => {
- match self.alloc_kind.get(&alloc_id.0) {
+ match self.alloc_kind.get(&alloc_id) {
// const eval results can refer to "locals".
// E.g. `const Foo: &u32 = &1;` refers to the temp local that stores the `1`
None |
@@ -587,7 +587,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
},
}
// overwrite or insert
- self.alloc_kind.insert(alloc_id.0, MemoryKind::MutableStatic);
+ self.alloc_kind.insert(alloc_id, MemoryKind::MutableStatic);
// take out the relocations vector to free the borrow on self, so we can call
// mark recursively
mem::replace(relocations, Default::default())
@@ -600,7 +600,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> Memory<'a, 'tcx, M> {
}
// put back the relocations
self.alloc_map
- .get_mut(&alloc_id.0)
+ .get_mut(&alloc_id)
.expect("checked above")
.relocations = relocations;
Ok(())
diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs
index 097f769adcf..ac16118c7af 100644
--- a/src/librustc_mir/interpret/place.rs
+++ b/src/librustc_mir/interpret/place.rs
@@ -194,8 +194,9 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
promoted: None,
};
let layout = self.layout_of(self.place_ty(mir_place))?;
+ let alloc = self.tcx.interpret_interner.borrow().get_cached(gid).expect("uncached global");
Place::Ptr {
- ptr: self.tcx.interpret_interner.borrow().get_cached(gid).expect("uncached global"),
+ ptr: MemoryPointer::new(alloc, 0).into(),
align: layout.align,
extra: PlaceExtra::None,
}
diff --git a/src/librustc_mir/interpret/step.rs b/src/librustc_mir/interpret/step.rs
index 140da7e1097..2b0f9041d51 100644
--- a/src/librustc_mir/interpret/step.rs
+++ b/src/librustc_mir/interpret/step.rs
@@ -180,7 +180,7 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
layout.align,
None,
)?;
- self.tcx.interpret_interner.borrow_mut().cache(cid, ptr.into());
+ self.tcx.interpret_interner.borrow_mut().cache(cid, ptr.alloc_id);
let internally_mutable = !layout.ty.is_freeze(self.tcx, self.param_env, span);
let mutability = if mutability == Mutability::Mutable || internally_mutable {
Mutability::Mutable
@@ -265,7 +265,7 @@ impl<'a, 'b, 'tcx, M: Machine<'tcx>> Visitor<'tcx> for ConstantExtractor<'a, 'b,
layout.align,
None,
)?;
- this.ecx.tcx.interpret_interner.borrow_mut().cache(cid, ptr.into());
+ this.ecx.tcx.interpret_interner.borrow_mut().cache(cid, ptr.alloc_id);
trace!("pushing stack frame for {:?}", index);
this.ecx.push_stack_frame(
this.instance,
diff --git a/src/librustc_mir/monomorphize/item.rs b/src/librustc_mir/monomorphize/item.rs
index 1f463cea764..9e547285b16 100644
--- a/src/librustc_mir/monomorphize/item.rs
+++ b/src/librustc_mir/monomorphize/item.rs
@@ -292,13 +292,13 @@ impl<'a, 'tcx> DefPathBasedNames<'a, 'tcx> {
ty::TyChar => output.push_str("char"),
ty::TyStr => output.push_str("str"),
ty::TyNever => output.push_str("!"),
- ty::TyInt(ast::IntTy::Is) => output.push_str("isize"),
+ ty::TyInt(ast::IntTy::Isize) => output.push_str("isize"),
ty::TyInt(ast::IntTy::I8) => output.push_str("i8"),
ty::TyInt(ast::IntTy::I16) => output.push_str("i16"),
ty::TyInt(ast::IntTy::I32) => output.push_str("i32"),
ty::TyInt(ast::IntTy::I64) => output.push_str("i64"),
ty::TyInt(ast::IntTy::I128) => output.push_str("i128"),
- ty::TyUint(ast::UintTy::Us) => output.push_str("usize"),
+ ty::TyUint(ast::UintTy::Usize) => output.push_str("usize"),
ty::TyUint(ast::UintTy::U8) => output.push_str("u8"),
ty::TyUint(ast::UintTy::U16) => output.push_str("u16"),
ty::TyUint(ast::UintTy::U32) => output.push_str("u32"),
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index f7d1c88fbc8..9f00bf97deb 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -1204,14 +1204,14 @@ impl PrimitiveTypeTable {
table.intern("char", TyChar);
table.intern("f32", TyFloat(FloatTy::F32));
table.intern("f64", TyFloat(FloatTy::F64));
- table.intern("isize", TyInt(IntTy::Is));
+ table.intern("isize", TyInt(IntTy::Isize));
table.intern("i8", TyInt(IntTy::I8));
table.intern("i16", TyInt(IntTy::I16));
table.intern("i32", TyInt(IntTy::I32));
table.intern("i64", TyInt(IntTy::I64));
table.intern("i128", TyInt(IntTy::I128));
table.intern("str", TyStr);
- table.intern("usize", TyUint(UintTy::Us));
+ table.intern("usize", TyUint(UintTy::Usize));
table.intern("u8", TyUint(UintTy::U8));
table.intern("u16", TyUint(UintTy::U16));
table.intern("u32", TyUint(UintTy::U32));
diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs
index 29871684092..60b24a578c6 100644
--- a/src/librustc_trans/back/lto.rs
+++ b/src/librustc_trans/back/lto.rs
@@ -607,7 +607,7 @@ impl ThinModule {
// into that context. One day, however, we may do this for upstream
// crates but for locally translated modules we may be able to reuse
// that LLVM Context and Module.
- let llcx = llvm::LLVMContextCreate();
+ let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
let llmod = llvm::LLVMRustParseBitcodeForThinLTO(
llcx,
self.data().as_ptr(),
diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs
index d8e95cd2cf2..4d1bcd9bf46 100644
--- a/src/librustc_trans/back/write.rs
+++ b/src/librustc_trans/back/write.rs
@@ -323,6 +323,7 @@ pub struct CodegenContext {
pub thinlto: bool,
pub no_landing_pads: bool,
pub save_temps: bool,
+ pub fewer_names: bool,
pub exported_symbols: Arc<ExportedSymbols>,
pub opts: Arc<config::Options>,
pub crate_types: Vec<config::CrateType>,
@@ -1407,6 +1408,7 @@ fn start_executing_work(tcx: TyCtxt,
unsafe { llvm::LLVMRustThinLTOAvailable() },
no_landing_pads: sess.no_landing_pads(),
+ fewer_names: sess.fewer_names(),
save_temps: sess.opts.cg.save_temps,
opts: Arc::new(sess.opts.clone()),
time_passes: sess.time_passes(),
diff --git a/src/librustc_trans/context.rs b/src/librustc_trans/context.rs
index d5e71062f74..248b37c43b4 100644
--- a/src/librustc_trans/context.rs
+++ b/src/librustc_trans/context.rs
@@ -197,7 +197,7 @@ pub fn is_pie_binary(sess: &Session) -> bool {
}
pub unsafe fn create_context_and_module(sess: &Session, mod_name: &str) -> (ContextRef, ModuleRef) {
- let llcx = llvm::LLVMContextCreate();
+ let llcx = llvm::LLVMRustContextCreate(sess.fewer_names());
let mod_name = CString::new(mod_name).unwrap();
let llmod = llvm::LLVMModuleCreateWithNameInContext(mod_name.as_ptr(), llcx);
diff --git a/src/librustc_trans/intrinsic.rs b/src/librustc_trans/intrinsic.rs
index cfddd99d0dd..23f7d47e722 100644
--- a/src/librustc_trans/intrinsic.rs
+++ b/src/librustc_trans/intrinsic.rs
@@ -1246,7 +1246,7 @@ fn generic_simd_intrinsic<'a, 'tcx>(
fn int_type_width_signed(ty: Ty, ccx: &CrateContext) -> Option<(u64, bool)> {
match ty.sty {
ty::TyInt(t) => Some((match t {
- ast::IntTy::Is => {
+ ast::IntTy::Isize => {
match &ccx.tcx().sess.target.target.target_pointer_width[..] {
"16" => 16,
"32" => 32,
@@ -1261,7 +1261,7 @@ fn int_type_width_signed(ty: Ty, ccx: &CrateContext) -> Option<(u64, bool)> {
ast::IntTy::I128 => 128,
}, true)),
ty::TyUint(t) => Some((match t {
- ast::UintTy::Us => {
+ ast::UintTy::Usize => {
match &ccx.tcx().sess.target.target.target_pointer_width[..] {
"16" => 16,
"32" => 32,
diff --git a/src/librustc_trans/mir/rvalue.rs b/src/librustc_trans/mir/rvalue.rs
index 65f1129890d..56309f20dc1 100644
--- a/src/librustc_trans/mir/rvalue.rs
+++ b/src/librustc_trans/mir/rvalue.rs
@@ -720,13 +720,13 @@ fn get_overflow_intrinsic(oop: OverflowOp, bcx: &Builder, ty: Ty) -> ValueRef {
let tcx = bcx.tcx();
let new_sty = match ty.sty {
- TyInt(Is) => match &tcx.sess.target.target.target_pointer_width[..] {
+ TyInt(Isize) => match &tcx.sess.target.target.target_pointer_width[..] {
"16" => TyInt(I16),
"32" => TyInt(I32),
"64" => TyInt(I64),
_ => panic!("unsupported target word size")
},
- TyUint(Us) => match &tcx.sess.target.target.target_pointer_width[..] {
+ TyUint(Usize) => match &tcx.sess.target.target.target_pointer_width[..] {
"16" => TyUint(U16),
"32" => TyUint(U32),
"64" => TyUint(U64),
diff --git a/src/librustc_trans/type_.rs b/src/librustc_trans/type_.rs
index b9daaf5a448..6cbe175d4d8 100644
--- a/src/librustc_trans/type_.rs
+++ b/src/librustc_trans/type_.rs
@@ -147,7 +147,7 @@ impl Type {
pub fn int_from_ty(ccx: &CrateContext, t: ast::IntTy) -> Type {
match t {
- ast::IntTy::Is => ccx.isize_ty(),
+ ast::IntTy::Isize => ccx.isize_ty(),
ast::IntTy::I8 => Type::i8(ccx),
ast::IntTy::I16 => Type::i16(ccx),
ast::IntTy::I32 => Type::i32(ccx),
@@ -158,7 +158,7 @@ impl Type {
pub fn uint_from_ty(ccx: &CrateContext, t: ast::UintTy) -> Type {
match t {
- ast::UintTy::Us => ccx.isize_ty(),
+ ast::UintTy::Usize => ccx.isize_ty(),
ast::UintTy::U8 => Type::i8(ccx),
ast::UintTy::U16 => Type::i16(ccx),
ast::UintTy::U32 => Type::i32(ccx),
diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs
index 7c199587c98..201997a74b7 100644
--- a/src/librustc_typeck/check/cast.rs
+++ b/src/librustc_typeck/check/cast.rs
@@ -233,7 +233,7 @@ impl<'a, 'gcx, 'tcx> CastCheck<'tcx> {
CastError::NeedViaPtr => {
let mut err = make_invalid_casting_error(fcx.tcx.sess, self.span, self.expr_ty,
self.cast_ty, fcx);
- if self.cast_ty.is_uint() {
+ if self.cast_ty.is_integral() {
err.help(&format!("cast through {} first",
match e {
CastError::NeedViaPtr => "a raw pointer",
diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
index 53bb0e577a4..6f83ecab01a 100644
--- a/src/librustc_typeck/check/method/probe.rs
+++ b/src/librustc_typeck/check/method/probe.rs
@@ -494,7 +494,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
let lang_def_id = lang_items.i128_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyInt(ast::IntTy::Is) => {
+ ty::TyInt(ast::IntTy::Isize) => {
let lang_def_id = lang_items.isize_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
@@ -518,7 +518,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
let lang_def_id = lang_items.u128_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::TyUint(ast::UintTy::Us) => {
+ ty::TyUint(ast::UintTy::Usize) => {
let lang_def_id = lang_items.usize_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 7a49c3549ab..6d68824980b 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -2219,7 +2219,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// First, try built-in indexing.
match (adjusted_ty.builtin_index(), &index_ty.sty) {
- (Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
+ (Some(ty), &ty::TyUint(ast::UintTy::Usize)) |
+ (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
debug!("try_index_step: success, using built-in indexing");
let adjustments = autoderef.adjust_steps(lvalue_pref);
self.apply_adjustments(base_expr, adjustments);
diff --git a/src/librustc_typeck/coherence/inherent_impls.rs b/src/librustc_typeck/coherence/inherent_impls.rs
index 569b6a2febb..4256a1fe12b 100644
--- a/src/librustc_typeck/coherence/inherent_impls.rs
+++ b/src/librustc_typeck/coherence/inherent_impls.rs
@@ -200,7 +200,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for InherentCollect<'a, 'tcx> {
"i128",
item.span);
}
- ty::TyInt(ast::IntTy::Is) => {
+ ty::TyInt(ast::IntTy::Isize) => {
self.check_primitive_impl(def_id,
lang_items.isize_impl(),
"isize",
@@ -242,7 +242,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for InherentCollect<'a, 'tcx> {
"u128",
item.span);
}
- ty::TyUint(ast::UintTy::Us) => {
+ ty::TyUint(ast::UintTy::Usize) => {
self.check_primitive_impl(def_id,
lang_items.usize_impl(),
"usize",
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 10cb2e5f3fd..265114ae826 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2011,7 +2011,7 @@ impl PrimitiveType {
impl From<ast::IntTy> for PrimitiveType {
fn from(int_ty: ast::IntTy) -> PrimitiveType {
match int_ty {
- ast::IntTy::Is => PrimitiveType::Isize,
+ ast::IntTy::Isize => PrimitiveType::Isize,
ast::IntTy::I8 => PrimitiveType::I8,
ast::IntTy::I16 => PrimitiveType::I16,
ast::IntTy::I32 => PrimitiveType::I32,
@@ -2024,7 +2024,7 @@ impl From<ast::IntTy> for PrimitiveType {
impl From<ast::UintTy> for PrimitiveType {
fn from(uint_ty: ast::UintTy) -> PrimitiveType {
match uint_ty {
- ast::UintTy::Us => PrimitiveType::Usize,
+ ast::UintTy::Usize => PrimitiveType::Usize,
ast::UintTy::U8 => PrimitiveType::U8,
ast::UintTy::U16 => PrimitiveType::U16,
ast::UintTy::U32 => PrimitiveType::U32,
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index 7f0e5a8d2aa..e9427fb40a0 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -527,6 +527,16 @@ impl<T, S> HashSet<T, S>
/// [`Hash`] and [`Eq`] on the borrowed form *must* match those for
/// the value type.
///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::collections::HashSet;
+ ///
+ /// let set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// assert_eq!(set.get(&2), Some(&2));
+ /// assert_eq!(set.get(&4), None);
+ /// ```
+ ///
/// [`Eq`]: ../../std/cmp/trait.Eq.html
/// [`Hash`]: ../../std/hash/trait.Hash.html
#[stable(feature = "set_recovery", since = "1.9.0")]
@@ -631,6 +641,19 @@ impl<T, S> HashSet<T, S>
/// Adds a value to the set, replacing the existing value, if any, that is equal to the given
/// one. Returns the replaced value.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::collections::HashSet;
+ ///
+ /// let mut set = HashSet::new();
+ /// set.insert(Vec::<i32>::new());
+ ///
+ /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 0);
+ /// set.replace(Vec::with_capacity(10));
+ /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 10);
+ /// ```
#[stable(feature = "set_recovery", since = "1.9.0")]
pub fn replace(&mut self, value: T) -> Option<T> {
Recover::replace(&mut self.map, value)
@@ -671,6 +694,16 @@ impl<T, S> HashSet<T, S>
/// [`Hash`] and [`Eq`] on the borrowed form *must* match those for
/// the value type.
///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::collections::HashSet;
+ ///
+ /// let mut set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+ /// assert_eq!(set.take(&2), Some(2));
+ /// assert_eq!(set.take(&2), None);
+ /// ```
+ ///
/// [`Eq`]: ../../std/cmp/trait.Eq.html
/// [`Hash`]: ../../std/hash/trait.Hash.html
#[stable(feature = "set_recovery", since = "1.9.0")]
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 15682b2d459..e08a2cbfd08 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -1324,7 +1324,7 @@ pub enum ImplItemKind {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy,
PartialOrd, Ord)]
pub enum IntTy {
- Is,
+ Isize,
I8,
I16,
I32,
@@ -1347,7 +1347,7 @@ impl fmt::Display for IntTy {
impl IntTy {
pub fn ty_to_string(&self) -> &'static str {
match *self {
- IntTy::Is => "isize",
+ IntTy::Isize => "isize",
IntTy::I8 => "i8",
IntTy::I16 => "i16",
IntTy::I32 => "i32",
@@ -1365,7 +1365,7 @@ impl IntTy {
pub fn bit_width(&self) -> Option<usize> {
Some(match *self {
- IntTy::Is => return None,
+ IntTy::Isize => return None,
IntTy::I8 => 8,
IntTy::I16 => 16,
IntTy::I32 => 32,
@@ -1378,7 +1378,7 @@ impl IntTy {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy,
PartialOrd, Ord)]
pub enum UintTy {
- Us,
+ Usize,
U8,
U16,
U32,
@@ -1389,7 +1389,7 @@ pub enum UintTy {
impl UintTy {
pub fn ty_to_string(&self) -> &'static str {
match *self {
- UintTy::Us => "usize",
+ UintTy::Usize => "usize",
UintTy::U8 => "u8",
UintTy::U16 => "u16",
UintTy::U32 => "u32",
@@ -1404,7 +1404,7 @@ impl UintTy {
pub fn bit_width(&self) -> Option<usize> {
Some(match *self {
- UintTy::Us => return None,
+ UintTy::Usize => return None,
UintTy::U8 => 8,
UintTy::U16 => 16,
UintTy::U32 => 32,
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index cc72ff7d15d..0b868b514fe 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -1071,8 +1071,8 @@ fn int_type_of_word(s: &str) -> Option<IntType> {
"u64" => Some(UnsignedInt(ast::UintTy::U64)),
"i128" => Some(SignedInt(ast::IntTy::I128)),
"u128" => Some(UnsignedInt(ast::UintTy::U128)),
- "isize" => Some(SignedInt(ast::IntTy::Is)),
- "usize" => Some(UnsignedInt(ast::UintTy::Us)),
+ "isize" => Some(SignedInt(ast::IntTy::Isize)),
+ "usize" => Some(UnsignedInt(ast::UintTy::Usize)),
_ => None
}
}
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 34e5610901e..be0bfd6677b 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -694,17 +694,17 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
}
fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr> {
self.expr_lit(span, ast::LitKind::Int(i as u128,
- ast::LitIntType::Unsigned(ast::UintTy::Us)))
+ ast::LitIntType::Unsigned(ast::UintTy::Usize)))
}
fn expr_isize(&self, sp: Span, i: isize) -> P<ast::Expr> {
if i < 0 {
let i = (-i) as u128;
- let lit_ty = ast::LitIntType::Signed(ast::IntTy::Is);
+ let lit_ty = ast::LitIntType::Signed(ast::IntTy::Isize);
let lit = self.expr_lit(sp, ast::LitKind::Int(i, lit_ty));
self.expr_unary(sp, ast::UnOp::Neg, lit)
} else {
self.expr_lit(sp, ast::LitKind::Int(i as u128,
- ast::LitIntType::Signed(ast::IntTy::Is)))
+ ast::LitIntType::Signed(ast::IntTy::Isize)))
}
}
fn expr_u32(&self, sp: Span, u: u32) -> P<ast::Expr> {
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 59996d1e4a7..7fcd88c94ca 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -326,13 +326,13 @@ pub mod rt {
);
}
- impl_to_tokens_int! { signed, isize, ast::IntTy::Is }
+ impl_to_tokens_int! { signed, isize, ast::IntTy::Isize }
impl_to_tokens_int! { signed, i8, ast::IntTy::I8 }
impl_to_tokens_int! { signed, i16, ast::IntTy::I16 }
impl_to_tokens_int! { signed, i32, ast::IntTy::I32 }
impl_to_tokens_int! { signed, i64, ast::IntTy::I64 }
- impl_to_tokens_int! { unsigned, usize, ast::UintTy::Us }
+ impl_to_tokens_int! { unsigned, usize, ast::UintTy::Usize }
impl_to_tokens_int! { unsigned, u8, ast::UintTy::U8 }
impl_to_tokens_int! { unsigned, u16, ast::UintTy::U16 }
impl_to_tokens_int! { unsigned, u32, ast::UintTy::U32 }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index a38ceba2f45..a9b1e4aaa60 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -603,13 +603,13 @@ pub fn integer_lit(s: &str, suffix: Option<Symbol>, diag: Option<(Span, &Handler
err!(diag, |span, diag| diag.span_bug(span, "found empty literal suffix in Some"));
}
ty = match &*suf.as_str() {
- "isize" => ast::LitIntType::Signed(ast::IntTy::Is),
+ "isize" => ast::LitIntType::Signed(ast::IntTy::Isize),
"i8" => ast::LitIntType::Signed(ast::IntTy::I8),
"i16" => ast::LitIntType::Signed(ast::IntTy::I16),
"i32" => ast::LitIntType::Signed(ast::IntTy::I32),
"i64" => ast::LitIntType::Signed(ast::IntTy::I64),
"i128" => ast::LitIntType::Signed(ast::IntTy::I128),
- "usize" => ast::LitIntType::Unsigned(ast::UintTy::Us),
+ "usize" => ast::LitIntType::Unsigned(ast::UintTy::Usize),
"u8" => ast::LitIntType::Unsigned(ast::UintTy::U8),
"u16" => ast::LitIntType::Unsigned(ast::UintTy::U16),
"u32" => ast::LitIntType::Unsigned(ast::UintTy::U32),
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index 29f5196c9bd..48872cb1313 100644
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -833,14 +833,14 @@ fn find_repr_type_name(diagnostic: &Handler, type_attrs: &[ast::Attribute]) -> &
attr::ReprPacked | attr::ReprSimd | attr::ReprAlign(_) => continue,
attr::ReprExtern => "i32",
- attr::ReprInt(attr::SignedInt(ast::IntTy::Is)) => "isize",
+ attr::ReprInt(attr::SignedInt(ast::IntTy::Isize)) => "isize",
attr::ReprInt(attr::SignedInt(ast::IntTy::I8)) => "i8",
attr::ReprInt(attr::SignedInt(ast::IntTy::I16)) => "i16",
attr::ReprInt(attr::SignedInt(ast::IntTy::I32)) => "i32",
attr::ReprInt(attr::SignedInt(ast::IntTy::I64)) => "i64",
attr::ReprInt(attr::SignedInt(ast::IntTy::I128)) => "i128",
- attr::ReprInt(attr::UnsignedInt(ast::UintTy::Us)) => "usize",
+ attr::ReprInt(attr::UnsignedInt(ast::UintTy::Usize)) => "usize",
attr::ReprInt(attr::UnsignedInt(ast::UintTy::U8)) => "u8",
attr::ReprInt(attr::UnsignedInt(ast::UintTy::U16)) => "u16",
attr::ReprInt(attr::UnsignedInt(ast::UintTy::U32)) => "u32",
diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp
index 96fb05ee06e..0fac7f7bf28 100644
--- a/src/rustllvm/RustWrapper.cpp
+++ b/src/rustllvm/RustWrapper.cpp
@@ -76,11 +76,17 @@ extern "C" char *LLVMRustGetLastError(void) {
return Ret;
}
-void LLVMRustSetLastError(const char *Err) {
+extern "C" void LLVMRustSetLastError(const char *Err) {
free((void *)LastError);
LastError = strdup(Err);
}
+extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) {
+ auto ctx = new LLVMContext();
+ ctx->setDiscardValueNames(shouldDiscardNames);
+ return wrap(ctx);
+}
+
extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
const char *Triple) {
unwrap(M)->setTargetTriple(Triple::normalize(Triple));
diff --git a/src/rustllvm/rustllvm.h b/src/rustllvm/rustllvm.h
index 8c2f855c226..714173f8602 100644
--- a/src/rustllvm/rustllvm.h
+++ b/src/rustllvm/rustllvm.h
@@ -71,7 +71,7 @@
#include "llvm/IR/IRPrintingPasses.h"
#include "llvm/Linker/Linker.h"
-void LLVMRustSetLastError(const char *);
+extern "C" void LLVMRustSetLastError(const char *);
enum class LLVMRustResult { Success, Failure };
diff --git a/src/test/debuginfo/shadowed-variable.rs b/src/test/debuginfo/shadowed-variable.rs
index 5d3026734c1..6e4d94d26cd 100644
--- a/src/test/debuginfo/shadowed-variable.rs
+++ b/src/test/debuginfo/shadowed-variable.rs
@@ -9,7 +9,6 @@
// except according to those terms.
// min-lldb-version: 310
-// ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
// compile-flags:-g
// === GDB TESTS ===================================================================================
@@ -35,15 +34,15 @@
// gdb-command:continue
// gdb-command:print x
-// gdb-check:$5 = 10.5
+// gdb-check:$7 = 10.5
// gdb-command:print y
-// gdb-check:$6 = 20
+// gdb-check:$8 = 20
// gdb-command:continue
// gdb-command:print x
-// gdb-check:$5 = 11.5
+// gdb-check:$9 = 11.5
// gdb-command:print y
-// gdb-check:$6 = 20
+// gdb-check:$10 = 20
// gdb-command:continue
// === LLDB TESTS ==================================================================================
@@ -69,15 +68,15 @@
// lldb-command:continue
// lldb-command:print x
-// lldb-check:[...]$4 = 10.5
+// lldb-check:[...]$6 = 10.5
// lldb-command:print y
-// lldb-check:[...]$5 = 20
+// lldb-check:[...]$7 = 20
// lldb-command:continue
// lldb-command:print x
-// lldb-check:[...]$4 = 11.5
+// lldb-check:[...]$8 = 11.5
// lldb-command:print y
-// lldb-check:[...]$5 = 20
+// lldb-check:[...]$9 = 20
// lldb-command:continue
#![feature(omit_gdb_pretty_printer_section)]
diff --git a/src/test/ui/fat-ptr-cast.stderr b/src/test/ui/fat-ptr-cast.stderr
index 35a97749e00..b3c2b23cd32 100644
--- a/src/test/ui/fat-ptr-cast.stderr
+++ b/src/test/ui/fat-ptr-cast.stderr
@@ -11,18 +11,24 @@ error[E0606]: casting `&[i32]` as `isize` is invalid
|
21 | a as isize; //~ ERROR casting
| ^^^^^^^^^^
+ |
+ = help: cast through a raw pointer first
error[E0606]: casting `&[i32]` as `i16` is invalid
--> $DIR/fat-ptr-cast.rs:22:5
|
22 | a as i16; //~ ERROR casting `&[i32]` as `i16` is invalid
| ^^^^^^^^
+ |
+ = help: cast through a raw pointer first
error[E0606]: casting `&[i32]` as `u32` is invalid
--> $DIR/fat-ptr-cast.rs:23:5
|
23 | a as u32; //~ ERROR casting `&[i32]` as `u32` is invalid
| ^^^^^^^^
+ |
+ = help: cast through a raw pointer first
error[E0605]: non-primitive cast: `std::boxed::Box<[i32]>` as `usize`
--> $DIR/fat-ptr-cast.rs:24:5