@@ -169,15 +169,15 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
169
169
let ptr = self . memory . allocate ( s. len ( ) as u64 , 1 ) ?;
170
170
self . memory . write_bytes ( ptr, s. as_bytes ( ) ) ?;
171
171
self . memory . freeze ( ptr. alloc_id ) ?;
172
- Ok ( Value :: ByValPair ( PrimVal :: Ptr ( ptr) , PrimVal :: from_u64 ( s. len ( ) as u64 ) ) )
172
+ Ok ( Value :: ByValPair ( PrimVal :: Ptr ( ptr) , PrimVal :: from_u128 ( s. len ( ) as u128 ) ) )
173
173
}
174
174
175
175
pub ( super ) fn const_to_value ( & mut self , const_val : & ConstVal ) -> EvalResult < ' tcx , Value > {
176
176
use rustc:: middle:: const_val:: ConstVal :: * ;
177
177
use rustc_const_math:: ConstFloat ;
178
178
179
179
let primval = match * const_val {
180
- Integral ( const_int) => PrimVal :: Bytes ( const_int. to_u64_unchecked ( ) ) ,
180
+ Integral ( const_int) => PrimVal :: Bytes ( const_int. to_u128_unchecked ( ) ) ,
181
181
182
182
Float ( ConstFloat :: F32 ( f) ) => PrimVal :: from_f32 ( f) ,
183
183
Float ( ConstFloat :: F64 ( f) ) => PrimVal :: from_f64 ( f) ,
@@ -429,7 +429,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
429
429
430
430
General { discr, ref variants, .. } => {
431
431
if let mir:: AggregateKind :: Adt ( adt_def, variant, _, _) = * kind {
432
- let discr_val = adt_def. variants [ variant] . disr_val . to_u64_unchecked ( ) ;
432
+ let discr_val = adt_def. variants [ variant] . disr_val . to_u128_unchecked ( ) ;
433
433
let discr_size = discr. size ( ) . bytes ( ) ;
434
434
let discr_offset = variants[ variant] . offsets [ 0 ] . bytes ( ) ;
435
435
@@ -497,7 +497,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
497
497
CEnum { .. } => {
498
498
assert_eq ! ( operands. len( ) , 0 ) ;
499
499
if let mir:: AggregateKind :: Adt ( adt_def, variant, _, _) = * kind {
500
- let n = adt_def. variants [ variant] . disr_val . to_u64_unchecked ( ) ;
500
+ let n = adt_def. variants [ variant] . disr_val . to_u128_unchecked ( ) ;
501
501
self . write_primval ( dest, PrimVal :: Bytes ( n) , dest_ty) ?;
502
502
} else {
503
503
bug ! ( "tried to assign {:?} to Layout::CEnum" , kind) ;
@@ -556,7 +556,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
556
556
let src = self . eval_lvalue ( lvalue) ?;
557
557
let ty = self . lvalue_ty ( lvalue) ;
558
558
let ( _, len) = src. elem_ty_and_len ( ty) ;
559
- self . write_primval ( dest, PrimVal :: from_u64 ( len) , dest_ty) ?;
559
+ self . write_primval ( dest, PrimVal :: from_u128 ( len as u128 ) , dest_ty) ?;
560
560
}
561
561
562
562
Ref ( _, _, ref lvalue) => {
@@ -566,7 +566,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
566
566
567
567
let val = match extra {
568
568
LvalueExtra :: None => Value :: ByVal ( ptr) ,
569
- LvalueExtra :: Length ( len) => Value :: ByValPair ( ptr, PrimVal :: from_u64 ( len) ) ,
569
+ LvalueExtra :: Length ( len) => Value :: ByValPair ( ptr, PrimVal :: from_u128 ( len as u128 ) ) ,
570
570
LvalueExtra :: Vtable ( vtable) => Value :: ByValPair ( ptr, PrimVal :: Ptr ( vtable) ) ,
571
571
LvalueExtra :: DowncastVariant ( ..) =>
572
572
bug ! ( "attempted to take a reference to an enum downcast lvalue" ) ,
@@ -1028,6 +1028,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1028
1028
I16 => 2 ,
1029
1029
I32 => 4 ,
1030
1030
I64 => 8 ,
1031
+ I128 => 16 ,
1031
1032
Is => self . memory . pointer_size ( ) ,
1032
1033
} ;
1033
1034
PrimValKind :: from_int_size ( size)
@@ -1040,6 +1041,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1040
1041
U16 => 2 ,
1041
1042
U32 => 4 ,
1042
1043
U64 => 8 ,
1044
+ U128 => 16 ,
1043
1045
Us => self . memory . pointer_size ( ) ,
1044
1046
} ;
1045
1047
PrimValKind :: from_uint_size ( size)
@@ -1092,7 +1094,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1092
1094
ty:: TyBool if val. to_bytes ( ) ? > 1 => Err ( EvalError :: InvalidBool ) ,
1093
1095
1094
1096
ty:: TyChar if :: std:: char:: from_u32 ( val. to_bytes ( ) ? as u32 ) . is_none ( )
1095
- => Err ( EvalError :: InvalidChar ( val. to_bytes ( ) ? as u32 as u64 ) ) ,
1097
+ => Err ( EvalError :: InvalidChar ( val. to_bytes ( ) ? as u32 as u128 ) ) ,
1096
1098
1097
1099
_ => Ok ( ( ) ) ,
1098
1100
}
@@ -1115,7 +1117,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1115
1117
let c = self . memory . read_uint ( ptr, 4 ) ? as u32 ;
1116
1118
match :: std:: char:: from_u32 ( c) {
1117
1119
Some ( ch) => PrimVal :: from_char ( ch) ,
1118
- None => return Err ( EvalError :: InvalidChar ( c as u64 ) ) ,
1120
+ None => return Err ( EvalError :: InvalidChar ( c as u128 ) ) ,
1119
1121
}
1120
1122
}
1121
1123
@@ -1126,9 +1128,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1126
1128
I16 => 2 ,
1127
1129
I32 => 4 ,
1128
1130
I64 => 8 ,
1131
+ I128 => 16 ,
1129
1132
Is => self . memory . pointer_size ( ) ,
1130
1133
} ;
1131
- PrimVal :: from_i64 ( self . memory . read_int ( ptr, size) ?)
1134
+ PrimVal :: from_i128 ( self . memory . read_int ( ptr, size) ?)
1132
1135
}
1133
1136
1134
1137
ty:: TyUint ( uint_ty) => {
@@ -1138,9 +1141,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1138
1141
U16 => 2 ,
1139
1142
U32 => 4 ,
1140
1143
U64 => 8 ,
1144
+ U128 => 16 ,
1141
1145
Us => self . memory . pointer_size ( ) ,
1142
1146
} ;
1143
- PrimVal :: from_u64 ( self . memory . read_uint ( ptr, size) ?)
1147
+ PrimVal :: from_u128 ( self . memory . read_uint ( ptr, size) ?)
1144
1148
}
1145
1149
1146
1150
ty:: TyFloat ( FloatTy :: F32 ) => PrimVal :: from_f32 ( self . memory . read_f32 ( ptr) ?) ,
@@ -1159,7 +1163,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1159
1163
let extra = match self . tcx . struct_tail ( ty) . sty {
1160
1164
ty:: TyDynamic ( ..) => PrimVal :: Ptr ( self . memory . read_ptr ( extra) ?) ,
1161
1165
ty:: TySlice ( ..) |
1162
- ty:: TyStr => PrimVal :: from_u64 ( self . memory . read_usize ( extra) ?) ,
1166
+ ty:: TyStr => PrimVal :: from_u128 ( self . memory . read_usize ( extra) ? as u128 ) ,
1163
1167
_ => bug ! ( "unsized primval ptr read from {:?}" , ty) ,
1164
1168
} ;
1165
1169
return Ok ( Some ( Value :: ByValPair ( PrimVal :: Ptr ( p) , extra) ) ) ;
@@ -1171,9 +1175,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1171
1175
if let CEnum { discr, signed, .. } = * self . type_layout ( ty) ? {
1172
1176
let size = discr. size ( ) . bytes ( ) ;
1173
1177
if signed {
1174
- PrimVal :: from_i64 ( self . memory . read_int ( ptr, size) ?)
1178
+ PrimVal :: from_i128 ( self . memory . read_int ( ptr, size) ?)
1175
1179
} else {
1176
- PrimVal :: from_u64 ( self . memory . read_uint ( ptr, size) ?)
1180
+ PrimVal :: from_u128 ( self . memory . read_uint ( ptr, size) ?)
1177
1181
}
1178
1182
} else {
1179
1183
return Ok ( None ) ;
@@ -1220,7 +1224,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
1220
1224
match ( & src_pointee_ty. sty , & dest_pointee_ty. sty ) {
1221
1225
( & ty:: TyArray ( _, length) , & ty:: TySlice ( _) ) => {
1222
1226
let ptr = src. read_ptr ( & self . memory ) ?;
1223
- let len = PrimVal :: from_u64 ( length as u64 ) ;
1227
+ let len = PrimVal :: from_u128 ( length as u128 ) ;
1224
1228
let ptr = PrimVal :: Ptr ( ptr) ;
1225
1229
self . write_value ( Value :: ByValPair ( ptr, len) , dest, dest_ty) ?;
1226
1230
}
@@ -1454,6 +1458,7 @@ impl IntegerExt for layout::Integer {
1454
1458
I16 => Size :: from_bits ( 16 ) ,
1455
1459
I32 => Size :: from_bits ( 32 ) ,
1456
1460
I64 => Size :: from_bits ( 64 ) ,
1461
+ I128 => Size :: from_bits ( 128 ) ,
1457
1462
}
1458
1463
}
1459
1464
}
0 commit comments