Skip to content

Commit 47913ee

Browse files
committed
Address review comments
1 parent 208d764 commit 47913ee

File tree

7 files changed

+33
-71
lines changed

7 files changed

+33
-71
lines changed

src/librustc/ty/mod.rs

Lines changed: 3 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1831,6 +1831,7 @@ impl<'a, 'gcx, 'tcx> AdtDef {
18311831
) -> Option<Discr<'tcx>> {
18321832
let param_env = ParamEnv::empty(traits::Reveal::UserFacing);
18331833
let repr_type = self.repr.discr_type();
1834+
let bit_size = layout::Integer::from_attr(tcx, repr_type).size().bits();
18341835
let substs = Substs::identity_for_item(tcx.global_tcx(), expr_did);
18351836
let instance = ty::Instance::new(expr_did, substs);
18361837
let cid = GlobalId {
@@ -1844,22 +1845,10 @@ impl<'a, 'gcx, 'tcx> AdtDef {
18441845
}) => {
18451846
trace!("discriminants: {} ({:?})", b, repr_type);
18461847
let ty = repr_type.to_ty(tcx);
1847-
if ty.is_signed() {
1848-
let (ty, param_env) = tcx
1849-
.lift_to_global(&(ty, param_env))
1850-
.unwrap_or_else(|| {
1851-
bug!("MIR: discriminants({:?}, {:?}) got \
1852-
type with inference types/regions",
1853-
ty, param_env);
1854-
});
1855-
let size = tcx.global_tcx()
1856-
.layout_of(param_env.and(ty))
1857-
.expect("int layout")
1858-
.size
1859-
.bits();
1848+
if repr_type.is_signed() {
18601849
let val = b as i128;
18611850
// sign extend to i128
1862-
let amt = 128 - size;
1851+
let amt = 128 - bit_size;
18631852
let val = (val << amt) >> amt;
18641853
Some(Discr {
18651854
val: val as u128,

src/librustc_mir/hair/cx/mod.rs

Lines changed: 6 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -151,22 +151,13 @@ impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> {
151151

152152
pub fn type_bit_size(
153153
&self,
154-
ty: Ty<'tcx>,
154+
ty: Ty,
155155
) -> u64 {
156-
let tcx = self.tcx.global_tcx();
157-
let (ty, param_env) = self
158-
.tcx
159-
.lift_to_global(&(ty, self.param_env))
160-
.unwrap_or_else(|| {
161-
bug!("MIR: Cx::const_eval_literal({:?}, {:?}) got \
162-
type with inference types/regions",
163-
ty, self.param_env);
164-
});
165-
tcx
166-
.layout_of(param_env.and(ty))
167-
.expect("int layout")
168-
.size
169-
.bits()
156+
match ty.sty {
157+
ty::TyInt(ity) => ity.bit_width(),
158+
ty::TyUint(uty) => uty.bit_width(),
159+
_ => bug!("{} is not an integer", ty),
160+
}.map_or(self.tcx.data_layout.pointer_size.bits(), |n| n as u64)
170161
}
171162

172163
pub fn const_eval_literal(

src/librustc_mir/interpret/eval_context.rs

Lines changed: 11 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1256,20 +1256,20 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12561256
pointee_ty: Ty<'tcx>,
12571257
) -> EvalResult<'tcx, Value> {
12581258
let ptr_size = self.memory.pointer_size();
1259-
let p: Pointer = self.memory.read_ptr_sized_unsigned(ptr, ptr_align)?.into();
1259+
let p: Pointer = self.memory.read_ptr_sized(ptr, ptr_align)?.into();
12601260
if self.type_is_sized(pointee_ty) {
12611261
Ok(p.to_value())
12621262
} else {
12631263
trace!("reading fat pointer extra of type {}", pointee_ty);
12641264
let extra = ptr.offset(ptr_size, self)?;
12651265
match self.tcx.struct_tail(pointee_ty).sty {
12661266
ty::TyDynamic(..) => Ok(p.to_value_with_vtable(
1267-
self.memory.read_ptr_sized_unsigned(extra, ptr_align)?.to_ptr()?,
1267+
self.memory.read_ptr_sized(extra, ptr_align)?.to_ptr()?,
12681268
)),
12691269
ty::TySlice(..) | ty::TyStr => {
12701270
let len = self
12711271
.memory
1272-
.read_ptr_sized_unsigned(extra, ptr_align)?
1272+
.read_ptr_sized(extra, ptr_align)?
12731273
.to_bytes()?;
12741274
Ok(p.to_value_with_len(len as u64))
12751275
},
@@ -1284,7 +1284,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12841284
let ptr = ptr.to_ptr()?;
12851285
let val = match ty.sty {
12861286
ty::TyBool => {
1287-
let val = self.memory.read_primval(ptr, ptr_align, 1, false)?;
1287+
let val = self.memory.read_primval(ptr, ptr_align, 1)?;
12881288
let val = match val {
12891289
PrimVal::Bytes(0) => false,
12901290
PrimVal::Bytes(1) => true,
@@ -1294,7 +1294,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
12941294
PrimVal::from_bool(val)
12951295
}
12961296
ty::TyChar => {
1297-
let c = self.memory.read_primval(ptr, ptr_align, 4, false)?.to_bytes()? as u32;
1297+
let c = self.memory.read_primval(ptr, ptr_align, 4)?.to_bytes()? as u32;
12981298
match ::std::char::from_u32(c) {
12991299
Some(ch) => PrimVal::from_char(ch),
13001300
None => return err!(InvalidChar(c as u128)),
@@ -1311,7 +1311,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
13111311
I128 => 16,
13121312
Isize => self.memory.pointer_size(),
13131313
};
1314-
self.memory.read_primval(ptr, ptr_align, size, true)?
1314+
self.memory.read_primval(ptr, ptr_align, size)?
13151315
}
13161316

13171317
ty::TyUint(uint_ty) => {
@@ -1324,17 +1324,17 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
13241324
U128 => 16,
13251325
Usize => self.memory.pointer_size(),
13261326
};
1327-
self.memory.read_primval(ptr, ptr_align, size, false)?
1327+
self.memory.read_primval(ptr, ptr_align, size)?
13281328
}
13291329

13301330
ty::TyFloat(FloatTy::F32) => {
1331-
PrimVal::Bytes(self.memory.read_primval(ptr, ptr_align, 4, false)?.to_bytes()?)
1331+
PrimVal::Bytes(self.memory.read_primval(ptr, ptr_align, 4)?.to_bytes()?)
13321332
}
13331333
ty::TyFloat(FloatTy::F64) => {
1334-
PrimVal::Bytes(self.memory.read_primval(ptr, ptr_align, 8, false)?.to_bytes()?)
1334+
PrimVal::Bytes(self.memory.read_primval(ptr, ptr_align, 8)?.to_bytes()?)
13351335
}
13361336

1337-
ty::TyFnPtr(_) => self.memory.read_ptr_sized_unsigned(ptr, ptr_align)?,
1337+
ty::TyFnPtr(_) => self.memory.read_ptr_sized(ptr, ptr_align)?,
13381338
ty::TyRef(_, ref tam) |
13391339
ty::TyRawPtr(ref tam) => return self.read_ptr(ptr, ptr_align, tam.ty).map(Some),
13401340

@@ -1344,12 +1344,8 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
13441344
}
13451345

13461346
if let layout::Abi::Scalar(ref scalar) = self.layout_of(ty)?.abi {
1347-
let mut signed = false;
1348-
if let layout::Int(_, s) = scalar.value {
1349-
signed = s;
1350-
}
13511347
let size = scalar.value.size(self).bytes();
1352-
self.memory.read_primval(ptr, ptr_align, size, signed)?
1348+
self.memory.read_primval(ptr, ptr_align, size)?
13531349
} else {
13541350
return Ok(None);
13551351
}

src/librustc_mir/interpret/memory.rs

Lines changed: 9 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -655,7 +655,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
655655
Ok(())
656656
}
657657

658-
pub fn read_primval(&self, ptr: MemoryPointer, ptr_align: Align, size: u64, signed: bool) -> EvalResult<'tcx, PrimVal> {
658+
pub fn read_primval(&self, ptr: MemoryPointer, ptr_align: Align, size: u64) -> EvalResult<'tcx, PrimVal> {
659659
self.check_relocation_edges(ptr, size)?; // Make sure we don't read part of a pointer as a pointer
660660
let endianness = self.endianness();
661661
let bytes = self.get_bytes_unchecked(ptr, size, ptr_align.min(self.int_align(size)))?;
@@ -665,14 +665,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
665665
return Ok(PrimVal::Undef.into());
666666
}
667667
// Now we do the actual reading
668-
let bytes = if signed {
669-
let bytes = read_target_int(endianness, bytes).unwrap() as u128;
670-
let amt = 128 - (size * 8);
671-
// truncate (shift left to drop out leftover values, shift right to fill with zeroes)
672-
(bytes << amt) >> amt
673-
} else {
674-
read_target_uint(endianness, bytes).unwrap()
675-
};
668+
let bytes = read_target_uint(endianness, bytes).unwrap();
676669
// See if we got a pointer
677670
if size != self.pointer_size() {
678671
if self.relocations(ptr, size)?.count() != 0 {
@@ -689,8 +682,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
689682
Ok(PrimVal::Bytes(bytes))
690683
}
691684

692-
pub fn read_ptr_sized_unsigned(&self, ptr: MemoryPointer, ptr_align: Align) -> EvalResult<'tcx, PrimVal> {
693-
self.read_primval(ptr, ptr_align, self.pointer_size(), false)
685+
pub fn read_ptr_sized(&self, ptr: MemoryPointer, ptr_align: Align) -> EvalResult<'tcx, PrimVal> {
686+
self.read_primval(ptr, ptr_align, self.pointer_size())
694687
}
695688

696689
pub fn write_primval(&mut self, ptr: MemoryPointer, ptr_align: Align, val: PrimVal, size: u64, signed: bool) -> EvalResult<'tcx> {
@@ -901,13 +894,6 @@ pub fn read_target_uint(endianness: layout::Endian, mut source: &[u8]) -> Result
901894
}
902895
}
903896

904-
pub fn read_target_int(endianness: layout::Endian, mut source: &[u8]) -> Result<i128, io::Error> {
905-
match endianness {
906-
layout::Endian::Little => source.read_int128::<LittleEndian>(source.len()),
907-
layout::Endian::Big => source.read_int128::<BigEndian>(source.len()),
908-
}
909-
}
910-
911897
////////////////////////////////////////////////////////////////////////////////
912898
// Unaligned accesses
913899
////////////////////////////////////////////////////////////////////////////////
@@ -924,7 +910,7 @@ pub trait HasMemory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'mir, 'tcx>> {
924910
) -> EvalResult<'tcx, Pointer> {
925911
Ok(match value {
926912
Value::ByRef(ptr, align) => {
927-
self.memory().read_ptr_sized_unsigned(ptr.to_ptr()?, align)?
913+
self.memory().read_ptr_sized(ptr.to_ptr()?, align)?
928914
}
929915
Value::ByVal(ptr) |
930916
Value::ByValPair(ptr, _) => ptr,
@@ -938,8 +924,8 @@ pub trait HasMemory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'mir, 'tcx>> {
938924
match value {
939925
Value::ByRef(ref_ptr, align) => {
940926
let mem = self.memory();
941-
let ptr = mem.read_ptr_sized_unsigned(ref_ptr.to_ptr()?, align)?.into();
942-
let vtable = mem.read_ptr_sized_unsigned(
927+
let ptr = mem.read_ptr_sized(ref_ptr.to_ptr()?, align)?.into();
928+
let vtable = mem.read_ptr_sized(
943929
ref_ptr.offset(mem.pointer_size(), &mem.tcx.data_layout)?.to_ptr()?,
944930
align
945931
)?.to_ptr()?;
@@ -960,8 +946,8 @@ pub trait HasMemory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'mir, 'tcx>> {
960946
match value {
961947
Value::ByRef(ref_ptr, align) => {
962948
let mem = self.memory();
963-
let ptr = mem.read_ptr_sized_unsigned(ref_ptr.to_ptr()?, align)?.into();
964-
let len = mem.read_ptr_sized_unsigned(
949+
let ptr = mem.read_ptr_sized(ref_ptr.to_ptr()?, align)?.into();
950+
let len = mem.read_ptr_sized(
965951
ref_ptr.offset(mem.pointer_size(), &mem.tcx.data_layout)?.to_ptr()?,
966952
align
967953
)?.to_bytes()? as u64;

src/librustc_mir/interpret/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,4 +30,4 @@ pub use self::const_eval::{
3030

3131
pub use self::machine::Machine;
3232

33-
pub use self::memory::{write_target_uint, write_target_int, read_target_uint, read_target_int};
33+
pub use self::memory::{write_target_uint, write_target_int, read_target_uint};

src/librustc_mir/interpret/terminator/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -401,7 +401,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
401401
let ptr_size = self.memory.pointer_size();
402402
let ptr_align = self.tcx.data_layout.pointer_align;
403403
let (ptr, vtable) = self.into_ptr_vtable_pair(args[0].value)?;
404-
let fn_ptr = self.memory.read_ptr_sized_unsigned(
404+
let fn_ptr = self.memory.read_ptr_sized(
405405
vtable.offset(ptr_size * (idx as u64 + 3), &self)?,
406406
ptr_align
407407
)?.to_ptr()?;

src/librustc_mir/interpret/traits.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -79,8 +79,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
7979
) -> EvalResult<'tcx, (Size, Align)> {
8080
let pointer_size = self.memory.pointer_size();
8181
let pointer_align = self.tcx.data_layout.pointer_align;
82-
let size = self.memory.read_ptr_sized_unsigned(vtable.offset(pointer_size, self)?, pointer_align)?.to_bytes()? as u64;
83-
let align = self.memory.read_ptr_sized_unsigned(
82+
let size = self.memory.read_ptr_sized(vtable.offset(pointer_size, self)?, pointer_align)?.to_bytes()? as u64;
83+
let align = self.memory.read_ptr_sized(
8484
vtable.offset(pointer_size * 2, self)?,
8585
pointer_align
8686
)?.to_bytes()? as u64;

0 commit comments

Comments
 (0)