From f2c5472ed5dd2b38711375c469c54536e51e9cf3 Mon Sep 17 00:00:00 2001 From: Trevor Spiteri Date: Fri, 22 Dec 2017 15:09:51 +0100 Subject: doc: improve None condition doc for `checked_div` and `checked_rem` --- src/libcore/num/mod.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 851c0a0dd6f..788b4417d99 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -435,7 +435,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 /// @@ -457,7 +457,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 /// @@ -1599,7 +1599,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 /// @@ -1619,7 +1619,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 /// -- cgit 1.4.1-3-g733a5 From 9599066dcbff6b78c97fed816cf183e1577acff2 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Thu, 4 Jan 2018 02:14:53 +0200 Subject: rustc: remove misleading `Ty::is_uint` method. --- src/librustc/ty/sty.rs | 7 ------- src/librustc_typeck/check/cast.rs | 2 +- src/test/ui/fat-ptr-cast.stderr | 6 ++++++ 3 files changed, 7 insertions(+), 8 deletions(-) diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 433c72f4b2c..e7e1a349bd8 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, 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/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 -- cgit 1.4.1-3-g733a5 From 210ac01792878ce0d654e852b0c794c782c04e01 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Thu, 4 Jan 2018 03:12:04 +0200 Subject: rustc: use {U,I}size instead of {U,I}s shorthands. --- src/librustc/ich/impls_syntax.rs | 4 +- src/librustc/ty/context.rs | 8 ++-- src/librustc/ty/layout.rs | 2 +- src/librustc/ty/mod.rs | 2 +- src/librustc/ty/sty.rs | 2 +- src/librustc/ty/util.rs | 12 +++--- src/librustc_const_eval/eval.rs | 8 ++-- src/librustc_const_math/err.rs | 4 +- src/librustc_const_math/int.rs | 16 +++---- src/librustc_const_math/is.rs | 56 ------------------------- src/librustc_const_math/isize.rs | 56 +++++++++++++++++++++++++ src/librustc_const_math/lib.rs | 8 ++-- src/librustc_const_math/us.rs | 56 ------------------------- src/librustc_const_math/usize.rs | 56 +++++++++++++++++++++++++ src/librustc_lint/types.rs | 14 +++---- src/librustc_mir/build/expr/as_rvalue.rs | 4 +- src/librustc_mir/build/misc.rs | 4 +- src/librustc_mir/interpret/cast.rs | 8 ++-- src/librustc_mir/interpret/const_eval.rs | 4 +- src/librustc_mir/interpret/eval_context.rs | 8 ++-- src/librustc_mir/monomorphize/item.rs | 4 +- src/librustc_resolve/lib.rs | 4 +- src/librustc_trans/intrinsic.rs | 4 +- src/librustc_trans/mir/rvalue.rs | 4 +- src/librustc_trans/type_.rs | 4 +- src/librustc_typeck/check/method/probe.rs | 4 +- src/librustc_typeck/check/mod.rs | 3 +- src/librustc_typeck/coherence/inherent_impls.rs | 4 +- src/librustdoc/clean/mod.rs | 4 +- src/libsyntax/ast.rs | 12 +++--- src/libsyntax/attr.rs | 4 +- src/libsyntax/ext/build.rs | 6 +-- src/libsyntax/ext/quote.rs | 4 +- src/libsyntax/parse/mod.rs | 4 +- src/libsyntax_ext/deriving/generic/mod.rs | 4 +- 35 files changed, 201 insertions(+), 200 deletions(-) delete mode 100644 src/librustc_const_math/is.rs create mode 100644 src/librustc_const_math/isize.rs delete mode 100644 src/librustc_const_math/us.rs create mode 100644 src/librustc_const_math/usize.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/ty/context.rs b/src/librustc/ty/context.rs index e21eb8bbf8a..daecba9938c 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)), @@ -1912,7 +1912,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 +1923,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 e7e1a349bd8..cf784b7cafb 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -1505,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/is.rs deleted file mode 100644 index 50dfb601129..00000000000 --- a/src/librustc_const_math/is.rs +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use syntax::ast; -use super::err::*; - -/// Depending on the target only one variant is ever used in a compilation. -/// Anything else is an error. This invariant is checked at several locations -#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, Hash, Eq, PartialEq)] -pub enum ConstIsize { - Is16(i16), - Is32(i32), - Is64(i64), -} -pub use self::ConstIsize::*; - -impl ::std::fmt::Display for ConstIsize { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { - write!(fmt, "{}", self.as_i64()) - } -} - -impl ConstIsize { - pub fn as_i64(self) -> i64 { - match self { - Is16(i) => i as i64, - Is32(i) => i as i64, - Is64(i) => i, - } - } - pub fn new(i: i64, isize_ty: ast::IntTy) -> Result { - 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::I32 if i as i32 as i64 == i => Ok(Is32(i as i32)), - ast::IntTy::I32 => Err(LitOutOfRange(ast::IntTy::Is)), - ast::IntTy::I64 => Ok(Is64(i)), - _ => unreachable!(), - } - } - pub fn new_truncating(i: i128, isize_ty: ast::IntTy) -> Self { - match isize_ty { - ast::IntTy::I16 => Is16(i as i16), - ast::IntTy::I32 => Is32(i as i32), - ast::IntTy::I64 => Is64(i as i64), - _ => unreachable!(), - } - } -} diff --git a/src/librustc_const_math/isize.rs b/src/librustc_const_math/isize.rs new file mode 100644 index 00000000000..18acc782775 --- /dev/null +++ b/src/librustc_const_math/isize.rs @@ -0,0 +1,56 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use syntax::ast; +use super::err::*; + +/// Depending on the target only one variant is ever used in a compilation. +/// Anything else is an error. This invariant is checked at several locations +#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, Hash, Eq, PartialEq)] +pub enum ConstIsize { + Is16(i16), + Is32(i32), + Is64(i64), +} +pub use self::ConstIsize::*; + +impl ::std::fmt::Display for ConstIsize { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { + write!(fmt, "{}", self.as_i64()) + } +} + +impl ConstIsize { + pub fn as_i64(self) -> i64 { + match self { + Is16(i) => i as i64, + Is32(i) => i as i64, + Is64(i) => i, + } + } + pub fn new(i: i64, isize_ty: ast::IntTy) -> Result { + 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::Isize)), + ast::IntTy::I32 if i as i32 as i64 == i => Ok(Is32(i as i32)), + ast::IntTy::I32 => Err(LitOutOfRange(ast::IntTy::Isize)), + ast::IntTy::I64 => Ok(Is64(i)), + _ => unreachable!(), + } + } + pub fn new_truncating(i: i128, isize_ty: ast::IntTy) -> Self { + match isize_ty { + ast::IntTy::I16 => Is16(i as i16), + ast::IntTy::I32 => Is32(i as i32), + ast::IntTy::I64 => Is64(i as i64), + _ => 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/us.rs deleted file mode 100644 index 9876bc4d779..00000000000 --- a/src/librustc_const_math/us.rs +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright 2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use syntax::ast; -use super::err::*; - -/// Depending on the target only one variant is ever used in a compilation. -/// Anything else is an error. This invariant is checked at several locations -#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, Hash, Eq, PartialEq)] -pub enum ConstUsize { - Us16(u16), - Us32(u32), - Us64(u64), -} -pub use self::ConstUsize::*; - -impl ::std::fmt::Display for ConstUsize { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { - write!(fmt, "{}", self.as_u64()) - } -} - -impl ConstUsize { - pub fn as_u64(self) -> u64 { - match self { - Us16(i) => i as u64, - Us32(i) => i as u64, - Us64(i) => i, - } - } - pub fn new(i: u64, usize_ty: ast::UintTy) -> Result { - 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::U32 if i as u32 as u64 == i => Ok(Us32(i as u32)), - ast::UintTy::U32 => Err(ULitOutOfRange(ast::UintTy::Us)), - ast::UintTy::U64 => Ok(Us64(i)), - _ => unreachable!(), - } - } - pub fn new_truncating(i: u128, usize_ty: ast::UintTy) -> Self { - match usize_ty { - ast::UintTy::U16 => Us16(i as u16), - ast::UintTy::U32 => Us32(i as u32), - ast::UintTy::U64 => Us64(i as u64), - _ => unreachable!(), - } - } -} diff --git a/src/librustc_const_math/usize.rs b/src/librustc_const_math/usize.rs new file mode 100644 index 00000000000..56995f08f05 --- /dev/null +++ b/src/librustc_const_math/usize.rs @@ -0,0 +1,56 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use syntax::ast; +use super::err::*; + +/// Depending on the target only one variant is ever used in a compilation. +/// Anything else is an error. This invariant is checked at several locations +#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, Hash, Eq, PartialEq)] +pub enum ConstUsize { + Us16(u16), + Us32(u32), + Us64(u64), +} +pub use self::ConstUsize::*; + +impl ::std::fmt::Display for ConstUsize { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { + write!(fmt, "{}", self.as_u64()) + } +} + +impl ConstUsize { + pub fn as_u64(self) -> u64 { + match self { + Us16(i) => i as u64, + Us32(i) => i as u64, + Us64(i) => i, + } + } + pub fn new(i: u64, usize_ty: ast::UintTy) -> Result { + 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::Usize)), + ast::UintTy::U32 if i as u32 as u64 == i => Ok(Us32(i as u32)), + ast::UintTy::U32 => Err(ULitOutOfRange(ast::UintTy::Usize)), + ast::UintTy::U64 => Ok(Us64(i)), + _ => unreachable!(), + } + } + pub fn new_truncating(i: u128, usize_ty: ast::UintTy) -> Self { + match usize_ty { + ast::UintTy::U16 => Us16(i as u16), + ast::UintTy::U32 => Us32(i as u32), + ast::UintTy::U64 => Us64(i as u64), + _ => 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_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..d02b18fa77b 100644 --- a/src/librustc_mir/interpret/const_eval.rs +++ b/src/librustc_mir/interpret/const_eval.rs @@ -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..913e69fa945 100644 --- a/src/librustc_mir/interpret/eval_context.rs +++ b/src/librustc_mir/interpret/eval_context.rs @@ -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/monomorphize/item.rs b/src/librustc_mir/monomorphize/item.rs index c3fb126ea18..0880767bca2 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 b49d9d2c7cf..d94b73d7f3e 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/intrinsic.rs b/src/librustc_trans/intrinsic.rs index 3cd60e7f1bc..6b122627f09 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 9d705eda9fb..8d57b59e8c7 100644 --- a/src/librustc_trans/mir/rvalue.rs +++ b/src/librustc_trans/mir/rvalue.rs @@ -718,13 +718,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/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 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 for PrimitiveType { impl From 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/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 { 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 { 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 { "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 { 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 { 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 { 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, 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", -- cgit 1.4.1-3-g733a5 From 9a8f0a8cb050e647fc146363d6558a6c17155ce5 Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Thu, 4 Jan 2018 17:55:44 +0100 Subject: Make libpanic_unwind build on CloudABI. CloudABI uses LLVM's libunwind for stack unwinding. There was a small bug that went by unnoticed, namely that it was not built with -fno-rtti. This caused it to (indirectly) depend on the entire C++ runtime. Now that that issue has been resolved, it is also perfectly fine to make use of this library for programming languages other than C++. --- src/libpanic_unwind/lib.rs | 1 + 1 file changed, 1 insertion(+) 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"] -- cgit 1.4.1-3-g733a5 From 0907494ae1b310da5708d61a5ca4f20033dcc86a Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Fri, 5 Jan 2018 05:12:38 +0200 Subject: miri: use AllocId instead of u64. --- src/librustc/mir/interpret/mod.rs | 2 +- src/librustc/ty/context.rs | 32 ++++++------ src/librustc_mir/interpret/const_eval.rs | 8 +-- src/librustc_mir/interpret/eval_context.rs | 4 +- src/librustc_mir/interpret/machine.rs | 6 +-- src/librustc_mir/interpret/memory.rs | 84 +++++++++++++++--------------- src/librustc_mir/interpret/place.rs | 3 +- src/librustc_mir/interpret/step.rs | 4 +- 8 files changed, 71 insertions(+), 72 deletions(-) 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/ty/context.rs b/src/librustc/ty/context.rs index e21eb8bbf8a..e78bee7c01b 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -895,31 +895,29 @@ pub struct InterpretInterner<'tcx> { allocs: FxHashSet<&'tcx interpret::Allocation>, /// Allows obtaining function instance handles via a unique identifier - functions: FxHashMap>, + functions: FxHashMap>, /// Inverse map of `interpret_functions`. /// Used so we don't allocate a new pointer every time we need one - function_cache: FxHashMap, u64>, + function_cache: FxHashMap, interpret::AllocId>, /// Allows obtaining const allocs via a unique identifier - alloc_by_id: FxHashMap, + alloc_by_id: FxHashMap, /// 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::Pointer>, + alloc_cache: FxHashMap, 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, u64>, + literal_alloc_cache: FxHashMap, 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> { 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 { + ) -> Option { 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; diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs index a37cf41baab..3705534929f 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>( diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs index 89d0e91a7ec..000358f44b6 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> { 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>, + alloc_kind: HashMap>, /// Actual memory allocations (arbitrary bytes, may contain pointers into other allocations). - alloc_map: HashMap, + alloc_map: HashMap, /// 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, + uninitialized_statics: HashMap, /// 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 { - 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, -- cgit 1.4.1-3-g733a5 From 7948f458ab28dc3476e764850a15f62f594609b1 Mon Sep 17 00:00:00 2001 From: Stjepan Glavina Date: Fri, 5 Jan 2018 15:02:10 +0100 Subject: Write examples for {BTree,Hash}Set::{get,replace,take} --- src/liballoc/btree/set.rs | 33 +++++++++++++++++++++++++++++++++ src/libstd/collections/hash/set.rs | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+) 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 BTreeSet { /// 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(&self, value: &Q) -> Option<&T> where T: Borrow, @@ -540,6 +550,19 @@ impl BTreeSet { /// 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::::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 { Recover::replace(&mut self.map, value) @@ -576,6 +599,16 @@ impl BTreeSet { /// 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(&mut self, value: &Q) -> Option where T: Borrow, 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 HashSet /// [`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 HashSet /// 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::::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 { Recover::replace(&mut self.map, value) @@ -671,6 +694,16 @@ impl HashSet /// [`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")] -- cgit 1.4.1-3-g733a5 From b719578f48c06047aea5f5b307ec1e3affb8f4ff Mon Sep 17 00:00:00 2001 From: Simonas Kazlauskas Date: Thu, 4 Jan 2018 22:19:23 +0200 Subject: Use name-discarding LLVM context This is only applicable when neither of --emit=llvm-ir or --emit=llvm-bc are not requested. In case either of these outputs are wanted, but the benefits of such context are desired as well, -Zfewer_names option provides the same functionality regardless of the outputs requested. --- src/librustc/session/config.rs | 6 ++++++ src/librustc/session/mod.rs | 9 ++++++++- src/librustc_llvm/ffi.rs | 2 +- src/librustc_trans/back/lto.rs | 2 +- src/librustc_trans/back/write.rs | 2 ++ src/librustc_trans/context.rs | 2 +- src/rustllvm/RustWrapper.cpp | 8 +++++++- src/rustllvm/rustllvm.h | 2 +- 8 files changed, 27 insertions(+), 6 deletions(-) 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 54bcc64d068..9e09a5d8fbe 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_llvm/ffi.rs b/src/librustc_llvm/ffi.rs index 7d653494465..274a0d7cca8 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_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, pub opts: Arc, pub crate_types: Vec, @@ -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/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 6f51ea67cb1..1ebbd73e6fe 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 }; -- cgit 1.4.1-3-g733a5 From 91611fc3d0ee8a7a0a7accff4377e3a21fd7b6c4 Mon Sep 17 00:00:00 2001 From: Ed Schouten Date: Fri, 5 Jan 2018 22:16:54 +0100 Subject: Let libpanic_abort call into libc's abort() on CloudABI. Ideally, we should make use of CloudABI's internal proc_raise(SIGABRT) system call. POSIX abort() requires things like flushing of stdios, which may not be what we want under panic conditions. Invoking the raw CloudABI system call would have prevented that. Unfortunately, we have to make use of the "cloudabi" crate to invoke raw CloudABI system calls. This is undesired, as discussed in the pull request (#47190). --- src/libpanic_abort/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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(); -- cgit 1.4.1-3-g733a5 From 7c971b2ab18f73a03c05f6349e314461be8b8c32 Mon Sep 17 00:00:00 2001 From: Sam Date: Sat, 6 Jan 2018 11:05:31 +0000 Subject: Debuginfo Shadowed Variable test: fix check numbering --- src/test/debuginfo/shadowed-variable.rs | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) 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)] -- cgit 1.4.1-3-g733a5