src/librustc/mir/interpret/value.rs

   1 use rustc_apfloat::{
   2     ieee::{Double, Single},
   3     Float,
   4 };
   5 use rustc_macros::HashStable;
   6 use std::fmt;
   7
   8 use crate::ty::{
   9     layout::{HasDataLayout, Size},
  10     ParamEnv, Ty, TyCtxt,
  11 };
  12
  13 use super::{sign_extend, truncate, AllocId, Allocation, InterpResult, Pointer, PointerArithmetic};
  14
  15 /// Represents the result of a raw const operation, pre-validation.
  16 #[derive(Clone, HashStable)]
  17 pub struct RawConst<'tcx> {
  18     // the value lives here, at offset 0, and that allocation definitely is a `AllocKind::Memory`
  19     // (so you can use `AllocMap::unwrap_memory`).
  20     pub alloc_id: AllocId,
  21     pub ty: Ty<'tcx>,
  22 }
  23
  24 /// Represents a constant value in Rust. `Scalar` and `Slice` are optimizations for
  25 /// array length computations, enum discriminants and the pattern matching logic.
  26 #[derive(
  27     Copy,
  28     Clone,
  29     Debug,
  30     Eq,
  31     PartialEq,
  32     PartialOrd,
  33     Ord,
  34     RustcEncodable,
  35     RustcDecodable,
  36     Hash,
  37     HashStable
  38 )]
  39 pub enum ConstValue<'tcx> {
  40     /// Used only for types with `layout::abi::Scalar` ABI and ZSTs.
  41     ///
  42     /// Not using the enum `Value` to encode that this must not be `Undef`.
  43     Scalar(Scalar),
  44
  45     /// Used only for `&[u8]` and `&str`
  46     Slice { data: &'tcx Allocation, start: usize, end: usize },
  47
  48     /// A value not represented/representable by `Scalar` or `Slice`
  49     ByRef {
  50         /// The backing memory of the value, may contain more memory than needed for just the value
  51         /// in order to share `Allocation`s between values
  52         alloc: &'tcx Allocation,
  53         /// Offset into `alloc`
  54         offset: Size,
  55     },
  56 }
  57
  58 #[cfg(target_arch = "x86_64")]
  59 static_assert_size!(ConstValue<'_>, 32);
  60
  61 impl<'tcx> ConstValue<'tcx> {
  62     #[inline]
  63     pub fn try_to_scalar(&self) -> Option<Scalar> {
  64         match *self {
  65             ConstValue::ByRef { .. } | ConstValue::Slice { .. } => None,
  66             ConstValue::Scalar(val) => Some(val),
  67         }
  68     }
  69
  70     pub fn try_to_bits(&self, size: Size) -> Option<u128> {
  71         self.try_to_scalar()?.to_bits(size).ok()
  72     }
  73
  74     pub fn try_to_bits_for_ty(
  75         &self,
  76         tcx: TyCtxt<'tcx>,
  77         param_env: ParamEnv<'tcx>,
  78         ty: Ty<'tcx>,
  79     ) -> Option<u128> {
  80         let size = tcx.layout_of(param_env.with_reveal_all().and(ty)).ok()?.size;
  81         self.try_to_bits(size)
  82     }
  83
  84     pub fn from_bool(b: bool) -> Self {
  85         ConstValue::Scalar(Scalar::from_bool(b))
  86     }
  87
  88     pub fn from_u64(i: u64) -> Self {
  89         ConstValue::Scalar(Scalar::from_u64(i))
  90     }
  91
  92     pub fn from_machine_usize(i: u64, cx: &impl HasDataLayout) -> Self {
  93         ConstValue::Scalar(Scalar::from_machine_usize(i, cx))
  94     }
  95 }
  96
  97 /// A `Scalar` represents an immediate, primitive value existing outside of a
  98 /// `memory::Allocation`. It is in many ways like a small chunk of a `Allocation`, up to 8 bytes in
  99 /// size. Like a range of bytes in an `Allocation`, a `Scalar` can either represent the raw bytes
 100 /// of a simple value or a pointer into another `Allocation`
 101 #[derive(
 102     Clone,
 103     Copy,
 104     Eq,
 105     PartialEq,
 106     Ord,
 107     PartialOrd,
 108     RustcEncodable,
 109     RustcDecodable,
 110     Hash,
 111     HashStable
 112 )]
 113 pub enum Scalar<Tag = (), Id = AllocId> {
 114     /// The raw bytes of a simple value.
 115     Raw {
 116         /// The first `size` bytes of `data` are the value.
 117         /// Do not try to read less or more bytes than that. The remaining bytes must be 0.
 118         data: u128,
 119         size: u8,
 120     },
 121
 122     /// A pointer into an `Allocation`. An `Allocation` in the `memory` module has a list of
 123     /// relocations, but a `Scalar` is only large enough to contain one, so we just represent the
 124     /// relocation and its associated offset together as a `Pointer` here.
 125     Ptr(Pointer<Tag, Id>),
 126 }
 127
 128 #[cfg(target_arch = "x86_64")]
 129 static_assert_size!(Scalar, 24);
 130
 131 impl<Tag: fmt::Debug, Id: fmt::Debug> fmt::Debug for Scalar<Tag, Id> {
 132     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 133         match self {
 134             Scalar::Ptr(ptr) => write!(f, "{:?}", ptr),
 135             &Scalar::Raw { data, size } => {
 136                 Scalar::check_data(data, size);
 137                 if size == 0 {
 138                     write!(f, "<ZST>")
 139                 } else {
 140                     // Format as hex number wide enough to fit any value of the given `size`.
 141                     // So data=20, size=1 will be "0x14", but with size=4 it'll be "0x00000014".
 142                     write!(f, "0x{:>0width$x}", data, width = (size * 2) as usize)
 143                 }
 144             }
 145         }
 146     }
 147 }
 148
 149 impl<Tag> fmt::Display for Scalar<Tag> {
 150     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 151         match self {
 152             Scalar::Ptr(_) => write!(f, "a pointer"),
 153             Scalar::Raw { data, .. } => write!(f, "{}", data),
 154         }
 155     }
 156 }
 157
 158 impl<Tag> From<Single> for Scalar<Tag> {
 159     #[inline(always)]
 160     fn from(f: Single) -> Self {
 161         Scalar::from_f32(f)
 162     }
 163 }
 164
 165 impl<Tag> From<Double> for Scalar<Tag> {
 166     #[inline(always)]
 167     fn from(f: Double) -> Self {
 168         Scalar::from_f64(f)
 169     }
 170 }
 171
 172 impl Scalar<()> {
 173     /// Make sure the `data` fits in `size`.
 174     /// This is guaranteed by all constructors here, but since the enum variants are public,
 175     /// it could still be violated (even though no code outside this file should
 176     /// construct `Scalar`s).
 177     #[inline(always)]
 178     fn check_data(data: u128, size: u8) {
 179         debug_assert_eq!(
 180             truncate(data, Size::from_bytes(size as u64)),
 181             data,
 182             "Scalar value {:#x} exceeds size of {} bytes",
 183             data,
 184             size
 185         );
 186     }
 187
 188     /// Tag this scalar with `new_tag` if it is a pointer, leave it unchanged otherwise.
 189     ///
 190     /// Used by `MemPlace::replace_tag`.
 191     #[inline]
 192     pub fn with_tag<Tag>(self, new_tag: Tag) -> Scalar<Tag> {
 193         match self {
 194             Scalar::Ptr(ptr) => Scalar::Ptr(ptr.with_tag(new_tag)),
 195             Scalar::Raw { data, size } => Scalar::Raw { data, size },
 196         }
 197     }
 198 }
 199
 200 impl<'tcx, Tag> Scalar<Tag> {
 201     /// Erase the tag from the scalar, if any.
 202     ///
 203     /// Used by error reporting code to avoid having the error type depend on `Tag`.
 204     #[inline]
 205     pub fn erase_tag(self) -> Scalar {
 206         match self {
 207             Scalar::Ptr(ptr) => Scalar::Ptr(ptr.erase_tag()),
 208             Scalar::Raw { data, size } => Scalar::Raw { data, size },
 209         }
 210     }
 211
 212     #[inline]
 213     pub fn ptr_null(cx: &impl HasDataLayout) -> Self {
 214         Scalar::Raw { data: 0, size: cx.data_layout().pointer_size.bytes() as u8 }
 215     }
 216
 217     #[inline]
 218     pub fn zst() -> Self {
 219         Scalar::Raw { data: 0, size: 0 }
 220     }
 221
 222     #[inline]
 223     pub fn ptr_offset(self, i: Size, cx: &impl HasDataLayout) -> InterpResult<'tcx, Self> {
 224         let dl = cx.data_layout();
 225         match self {
 226             Scalar::Raw { data, size } => {
 227                 assert_eq!(size as u64, dl.pointer_size.bytes());
 228                 Ok(Scalar::Raw { data: dl.offset(data as u64, i.bytes())? as u128, size })
 229             }
 230             Scalar::Ptr(ptr) => ptr.offset(i, dl).map(Scalar::Ptr),
 231         }
 232     }
 233
 234     #[inline]
 235     pub fn ptr_wrapping_offset(self, i: Size, cx: &impl HasDataLayout) -> Self {
 236         let dl = cx.data_layout();
 237         match self {
 238             Scalar::Raw { data, size } => {
 239                 assert_eq!(size as u64, dl.pointer_size.bytes());
 240                 Scalar::Raw { data: dl.overflowing_offset(data as u64, i.bytes()).0 as u128, size }
 241             }
 242             Scalar::Ptr(ptr) => Scalar::Ptr(ptr.wrapping_offset(i, dl)),
 243         }
 244     }
 245
 246     #[inline]
 247     pub fn ptr_signed_offset(self, i: i64, cx: &impl HasDataLayout) -> InterpResult<'tcx, Self> {
 248         let dl = cx.data_layout();
 249         match self {
 250             Scalar::Raw { data, size } => {
 251                 assert_eq!(size as u64, dl.pointer_size().bytes());
 252                 Ok(Scalar::Raw { data: dl.signed_offset(data as u64, i)? as u128, size })
 253             }
 254             Scalar::Ptr(ptr) => ptr.signed_offset(i, dl).map(Scalar::Ptr),
 255         }
 256     }
 257
 258     #[inline]
 259     pub fn ptr_wrapping_signed_offset(self, i: i64, cx: &impl HasDataLayout) -> Self {
 260         let dl = cx.data_layout();
 261         match self {
 262             Scalar::Raw { data, size } => {
 263                 assert_eq!(size as u64, dl.pointer_size.bytes());
 264                 Scalar::Raw {
 265                     data: dl.overflowing_signed_offset(data as u64, i128::from(i)).0 as u128,
 266                     size,
 267                 }
 268             }
 269             Scalar::Ptr(ptr) => Scalar::Ptr(ptr.wrapping_signed_offset(i, dl)),
 270         }
 271     }
 272
 273     #[inline]
 274     pub fn from_bool(b: bool) -> Self {
 275         Scalar::Raw { data: b as u128, size: 1 }
 276     }
 277
 278     #[inline]
 279     pub fn from_char(c: char) -> Self {
 280         Scalar::Raw { data: c as u128, size: 4 }
 281     }
 282
 283     #[inline]
 284     pub fn try_from_uint(i: impl Into<u128>, size: Size) -> Option<Self> {
 285         let i = i.into();
 286         if truncate(i, size) == i {
 287             Some(Scalar::Raw { data: i, size: size.bytes() as u8 })
 288         } else {
 289             None
 290         }
 291     }
 292
 293     #[inline]
 294     pub fn from_uint(i: impl Into<u128>, size: Size) -> Self {
 295         let i = i.into();
 296         Self::try_from_uint(i, size)
 297             .unwrap_or_else(|| bug!("Unsigned value {:#x} does not fit in {} bits", i, size.bits()))
 298     }
 299
 300     #[inline]
 301     pub fn from_u8(i: u8) -> Self {
 302         Scalar::Raw { data: i as u128, size: 1 }
 303     }
 304
 305     #[inline]
 306     pub fn from_u16(i: u16) -> Self {
 307         Scalar::Raw { data: i as u128, size: 2 }
 308     }
 309
 310     #[inline]
 311     pub fn from_u32(i: u32) -> Self {
 312         Scalar::Raw { data: i as u128, size: 4 }
 313     }
 314
 315     #[inline]
 316     pub fn from_u64(i: u64) -> Self {
 317         Scalar::Raw { data: i as u128, size: 8 }
 318     }
 319
 320     #[inline]
 321     pub fn from_machine_usize(i: u64, cx: &impl HasDataLayout) -> Self {
 322         Self::from_uint(i, cx.data_layout().pointer_size)
 323     }
 324
 325     #[inline]
 326     pub fn try_from_int(i: impl Into<i128>, size: Size) -> Option<Self> {
 327         let i = i.into();
 328         // `into` performed sign extension, we have to truncate
 329         let truncated = truncate(i as u128, size);
 330         if sign_extend(truncated, size) as i128 == i {
 331             Some(Scalar::Raw { data: truncated, size: size.bytes() as u8 })
 332         } else {
 333             None
 334         }
 335     }
 336
 337     #[inline]
 338     pub fn from_int(i: impl Into<i128>, size: Size) -> Self {
 339         let i = i.into();
 340         Self::try_from_int(i, size)
 341             .unwrap_or_else(|| bug!("Signed value {:#x} does not fit in {} bits", i, size.bits()))
 342     }
 343
 344     #[inline]
 345     pub fn from_machine_isize(i: i64, cx: &impl HasDataLayout) -> Self {
 346         Self::from_int(i, cx.data_layout().pointer_size)
 347     }
 348
 349     #[inline]
 350     pub fn from_f32(f: Single) -> Self {
 351         // We trust apfloat to give us properly truncated data.
 352         Scalar::Raw { data: f.to_bits(), size: 4 }
 353     }
 354
 355     #[inline]
 356     pub fn from_f64(f: Double) -> Self {
 357         // We trust apfloat to give us properly truncated data.
 358         Scalar::Raw { data: f.to_bits(), size: 8 }
 359     }
 360
 361     /// This is very rarely the method you want!  You should dispatch on the type
 362     /// and use `force_bits`/`assert_bits`/`force_ptr`/`assert_ptr`.
 363     /// This method only exists for the benefit of low-level memory operations
 364     /// as well as the implementation of the `force_*` methods.
 365     #[inline]
 366     pub fn to_bits_or_ptr(
 367         self,
 368         target_size: Size,
 369         cx: &impl HasDataLayout,
 370     ) -> Result<u128, Pointer<Tag>> {
 371         match self {
 372             Scalar::Raw { data, size } => {
 373                 assert_eq!(target_size.bytes(), size as u64);
 374                 assert_ne!(size, 0, "you should never look at the bits of a ZST");
 375                 Scalar::check_data(data, size);
 376                 Ok(data)
 377             }
 378             Scalar::Ptr(ptr) => {
 379                 assert_eq!(target_size, cx.data_layout().pointer_size);
 380                 Err(ptr)
 381             }
 382         }
 383     }
 384
 385     #[inline(always)]
 386     pub fn check_raw(data: u128, size: u8, target_size: Size) {
 387         assert_eq!(target_size.bytes(), size as u64);
 388         assert_ne!(size, 0, "you should never look at the bits of a ZST");
 389         Scalar::check_data(data, size);
 390     }
 391
 392     /// Do not call this method!  Use either `assert_bits` or `force_bits`.
 393     #[inline]
 394     pub fn to_bits(self, target_size: Size) -> InterpResult<'tcx, u128> {
 395         match self {
 396             Scalar::Raw { data, size } => {
 397                 Self::check_raw(data, size, target_size);
 398                 Ok(data)
 399             }
 400             Scalar::Ptr(_) => throw_unsup!(ReadPointerAsBytes),
 401         }
 402     }
 403
 404     #[inline(always)]
 405     pub fn assert_bits(self, target_size: Size) -> u128 {
 406         self.to_bits(target_size).expect("expected Raw bits but got a Pointer")
 407     }
 408
 409     #[inline]
 410     pub fn assert_ptr(self) -> Pointer<Tag> {
 411         match self {
 412             Scalar::Ptr(p) => p,
 413             Scalar::Raw { .. } => bug!("expected a Pointer but got Raw bits")
 414         }
 415     }
 416
 417     /// Do not call this method!  Dispatch based on the type instead.
 418     #[inline]
 419     pub fn is_bits(self) -> bool {
 420         match self {
 421             Scalar::Raw { .. } => true,
 422             _ => false,
 423         }
 424     }
 425
 426     /// Do not call this method!  Dispatch based on the type instead.
 427     #[inline]
 428     pub fn is_ptr(self) -> bool {
 429         match self {
 430             Scalar::Ptr(_) => true,
 431             _ => false,
 432         }
 433     }
 434
 435     pub fn to_bool(self) -> InterpResult<'tcx, bool> {
 436         match self {
 437             Scalar::Raw { data: 0, size: 1 } => Ok(false),
 438             Scalar::Raw { data: 1, size: 1 } => Ok(true),
 439             _ => throw_unsup!(InvalidBool),
 440         }
 441     }
 442
 443     pub fn to_char(self) -> InterpResult<'tcx, char> {
 444         let val = self.to_u32()?;
 445         match ::std::char::from_u32(val) {
 446             Some(c) => Ok(c),
 447             None => throw_unsup!(InvalidChar(val as u128)),
 448         }
 449     }
 450
 451     #[inline]
 452     fn to_unsigned_with_bit_width(self, bits: u64) -> InterpResult<'static, u128> {
 453         let sz = Size::from_bits(bits);
 454         self.to_bits(sz)
 455     }
 456
 457     /// Converts the scalar to produce an `u8`. Fails if the scalar is a pointer.
 458     pub fn to_u8(self) -> InterpResult<'static, u8> {
 459         self.to_unsigned_with_bit_width(8).map(|v| v as u8)
 460     }
 461
 462     /// Converts the scalar to produce an `u16`. Fails if the scalar is a pointer.
 463     pub fn to_u16(self) -> InterpResult<'static, u16> {
 464         self.to_unsigned_with_bit_width(16).map(|v| v as u16)
 465     }
 466
 467     /// Converts the scalar to produce an `u32`. Fails if the scalar is a pointer.
 468     pub fn to_u32(self) -> InterpResult<'static, u32> {
 469         self.to_unsigned_with_bit_width(32).map(|v| v as u32)
 470     }
 471
 472     /// Converts the scalar to produce an `u64`. Fails if the scalar is a pointer.
 473     pub fn to_u64(self) -> InterpResult<'static, u64> {
 474         self.to_unsigned_with_bit_width(64).map(|v| v as u64)
 475     }
 476
 477     pub fn to_machine_usize(self, cx: &impl HasDataLayout) -> InterpResult<'static, u64> {
 478         let b = self.to_bits(cx.data_layout().pointer_size)?;
 479         Ok(b as u64)
 480     }
 481
 482     #[inline]
 483     fn to_signed_with_bit_width(self, bits: u64) -> InterpResult<'static, i128> {
 484         let sz = Size::from_bits(bits);
 485         let b = self.to_bits(sz)?;
 486         Ok(sign_extend(b, sz) as i128)
 487     }
 488
 489     /// Converts the scalar to produce an `i8`. Fails if the scalar is a pointer.
 490     pub fn to_i8(self) -> InterpResult<'static, i8> {
 491         self.to_signed_with_bit_width(8).map(|v| v as i8)
 492     }
 493
 494     /// Converts the scalar to produce an `i16`. Fails if the scalar is a pointer.
 495     pub fn to_i16(self) -> InterpResult<'static, i16> {
 496         self.to_signed_with_bit_width(16).map(|v| v as i16)
 497     }
 498
 499     /// Converts the scalar to produce an `i32`. Fails if the scalar is a pointer.
 500     pub fn to_i32(self) -> InterpResult<'static, i32> {
 501         self.to_signed_with_bit_width(32).map(|v| v as i32)
 502     }
 503
 504     /// Converts the scalar to produce an `i64`. Fails if the scalar is a pointer.
 505     pub fn to_i64(self) -> InterpResult<'static, i64> {
 506         self.to_signed_with_bit_width(64).map(|v| v as i64)
 507     }
 508
 509     pub fn to_machine_isize(self, cx: &impl HasDataLayout) -> InterpResult<'static, i64> {
 510         let sz = cx.data_layout().pointer_size;
 511         let b = self.to_bits(sz)?;
 512         let b = sign_extend(b, sz) as i128;
 513         Ok(b as i64)
 514     }
 515
 516     #[inline]
 517     pub fn to_f32(self) -> InterpResult<'static, Single> {
 518         // Going through `u32` to check size and truncation.
 519         Ok(Single::from_bits(self.to_u32()? as u128))
 520     }
 521
 522     #[inline]
 523     pub fn to_f64(self) -> InterpResult<'static, Double> {
 524         // Going through `u64` to check size and truncation.
 525         Ok(Double::from_bits(self.to_u64()? as u128))
 526     }
 527 }
 528
 529 impl<Tag> From<Pointer<Tag>> for Scalar<Tag> {
 530     #[inline(always)]
 531     fn from(ptr: Pointer<Tag>) -> Self {
 532         Scalar::Ptr(ptr)
 533     }
 534 }
 535
 536 #[derive(Clone, Copy, Eq, PartialEq, RustcEncodable, RustcDecodable, HashStable, Hash)]
 537 pub enum ScalarMaybeUndef<Tag = (), Id = AllocId> {
 538     Scalar(Scalar<Tag, Id>),
 539     Undef,
 540 }
 541
 542 impl<Tag> From<Scalar<Tag>> for ScalarMaybeUndef<Tag> {
 543     #[inline(always)]
 544     fn from(s: Scalar<Tag>) -> Self {
 545         ScalarMaybeUndef::Scalar(s)
 546     }
 547 }
 548
 549 impl<Tag> From<Pointer<Tag>> for ScalarMaybeUndef<Tag> {
 550     #[inline(always)]
 551     fn from(s: Pointer<Tag>) -> Self {
 552         ScalarMaybeUndef::Scalar(s.into())
 553     }
 554 }
 555
 556 impl<Tag: fmt::Debug, Id: fmt::Debug> fmt::Debug for ScalarMaybeUndef<Tag, Id> {
 557     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 558         match self {
 559             ScalarMaybeUndef::Undef => write!(f, "Undef"),
 560             ScalarMaybeUndef::Scalar(s) => write!(f, "{:?}", s),
 561         }
 562     }
 563 }
 564
 565 impl<Tag> fmt::Display for ScalarMaybeUndef<Tag> {
 566     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 567         match self {
 568             ScalarMaybeUndef::Undef => write!(f, "uninitialized bytes"),
 569             ScalarMaybeUndef::Scalar(s) => write!(f, "{}", s),
 570         }
 571     }
 572 }
 573
 574 impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
 575     /// Erase the tag from the scalar, if any.
 576     ///
 577     /// Used by error reporting code to avoid having the error type depend on `Tag`.
 578     #[inline]
 579     pub fn erase_tag(self) -> ScalarMaybeUndef {
 580         match self {
 581             ScalarMaybeUndef::Scalar(s) => ScalarMaybeUndef::Scalar(s.erase_tag()),
 582             ScalarMaybeUndef::Undef => ScalarMaybeUndef::Undef,
 583         }
 584     }
 585
 586     #[inline]
 587     pub fn not_undef(self) -> InterpResult<'static, Scalar<Tag>> {
 588         match self {
 589             ScalarMaybeUndef::Scalar(scalar) => Ok(scalar),
 590             ScalarMaybeUndef::Undef => throw_unsup!(ReadUndefBytes(Size::ZERO)),
 591         }
 592     }
 593
 594     /// Do not call this method!  Use either `assert_bits` or `force_bits`.
 595     #[inline(always)]
 596     pub fn to_bits(self, target_size: Size) -> InterpResult<'tcx, u128> {
 597         self.not_undef()?.to_bits(target_size)
 598     }
 599
 600     #[inline(always)]
 601     pub fn to_bool(self) -> InterpResult<'tcx, bool> {
 602         self.not_undef()?.to_bool()
 603     }
 604
 605     #[inline(always)]
 606     pub fn to_char(self) -> InterpResult<'tcx, char> {
 607         self.not_undef()?.to_char()
 608     }
 609
 610     #[inline(always)]
 611     pub fn to_f32(self) -> InterpResult<'tcx, Single> {
 612         self.not_undef()?.to_f32()
 613     }
 614
 615     #[inline(always)]
 616     pub fn to_f64(self) -> InterpResult<'tcx, Double> {
 617         self.not_undef()?.to_f64()
 618     }
 619
 620     #[inline(always)]
 621     pub fn to_u8(self) -> InterpResult<'tcx, u8> {
 622         self.not_undef()?.to_u8()
 623     }
 624
 625     #[inline(always)]
 626     pub fn to_u32(self) -> InterpResult<'tcx, u32> {
 627         self.not_undef()?.to_u32()
 628     }
 629
 630     #[inline(always)]
 631     pub fn to_u64(self) -> InterpResult<'tcx, u64> {
 632         self.not_undef()?.to_u64()
 633     }
 634
 635     #[inline(always)]
 636     pub fn to_machine_usize(self, cx: &impl HasDataLayout) -> InterpResult<'tcx, u64> {
 637         self.not_undef()?.to_machine_usize(cx)
 638     }
 639
 640     #[inline(always)]
 641     pub fn to_i8(self) -> InterpResult<'tcx, i8> {
 642         self.not_undef()?.to_i8()
 643     }
 644
 645     #[inline(always)]
 646     pub fn to_i32(self) -> InterpResult<'tcx, i32> {
 647         self.not_undef()?.to_i32()
 648     }
 649
 650     #[inline(always)]
 651     pub fn to_i64(self) -> InterpResult<'tcx, i64> {
 652         self.not_undef()?.to_i64()
 653     }
 654
 655     #[inline(always)]
 656     pub fn to_machine_isize(self, cx: &impl HasDataLayout) -> InterpResult<'tcx, i64> {
 657         self.not_undef()?.to_machine_isize(cx)
 658     }
 659 }
 660
 661 /// Gets the bytes of a constant slice value.
 662 pub fn get_slice_bytes<'tcx>(cx: &impl HasDataLayout, val: ConstValue<'tcx>) -> &'tcx [u8] {
 663     if let ConstValue::Slice { data, start, end } = val {
 664         let len = end - start;
 665         data.get_bytes(
 666             cx,
 667             // invent a pointer, only the offset is relevant anyway
 668             Pointer::new(AllocId(0), Size::from_bytes(start as u64)),
 669             Size::from_bytes(len as u64),
 670         )
 671         .unwrap_or_else(|err| bug!("const slice is invalid: {:?}", err))
 672     } else {
 673         bug!("expected const slice, but found another const value");
 674     }
 675 }