renaming err to err_unsup

saleemjaffer · saleemjaffer · commit fc5df1dfbfdd · 2019-07-30T16:08:32.000+05:30
diff --git a/src/librustc/mir/interpret/allocation.rs b/src/librustc/mir/interpret/allocation.rs
@@ -244,7 +244,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
                 Ok(&self.get_bytes(cx, ptr, size_with_null)?[..size])
             }
             // This includes the case where `offset` is out-of-bounds to begin with.
-            None => throw_err!(UnterminatedCString(ptr.erase_tag())),
+            None => throw_err_unsup!(UnterminatedCString(ptr.erase_tag())),
         }
     }
 
@@ -446,7 +446,7 @@ impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
         if self.relocations(cx, ptr, size).is_empty() {
             Ok(())
         } else {
-            throw_err!(ReadPointerAsBytes)
+            throw_err_unsup!(ReadPointerAsBytes)
         }
     }
 
@@ -516,7 +516,7 @@ impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
         self.undef_mask.is_range_defined(
             ptr.offset,
             ptr.offset + size,
-        ).or_else(|idx| throw_err!(ReadUndefBytes(idx)))
+        ).or_else(|idx| throw_err_unsup!(ReadUndefBytes(idx)))
     }
 
     pub fn mark_definedness(
diff --git a/src/librustc/mir/interpret/error.rs b/src/librustc/mir/interpret/error.rs
@@ -184,8 +184,8 @@ pub fn struct_error<'tcx>(tcx: TyCtxtAt<'tcx>, msg: &str) -> DiagnosticBuilder<'
 /// Packages the kind of error we got from the const code interpreter
 /// up with a Rust-level backtrace of where the error occured.
 /// Thsese should always be constructed by calling `.into()` on
-/// a `InterpError`. In `librustc_mir::interpret`, we have the `throw_err!`
-/// macro for this.
+/// a `InterpError`. In `librustc_mir::interpret`, we have `throw_err_*`
+/// macros for this.
 #[derive(Debug, Clone)]
 pub struct InterpErrorInfo<'tcx> {
     pub kind: InterpError<'tcx>,
diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs
@@ -1,7 +1,7 @@
 //! An interpreter for MIR used in CTFE and by miri
 
 #[macro_export]
-macro_rules! throw_err {
+macro_rules! throw_err_unsup {
     ($($tt:tt)*) => {
         Err($crate::mir::interpret::InterpError::Unsupported(
             $crate::mir::interpret::UnsupportedOpInfo::$($tt)*
@@ -55,7 +55,7 @@ macro_rules! err_inval {
 }
 
 #[macro_export]
-macro_rules! err {
+macro_rules! err_unsup {
     ($($tt:tt)*) => {
         $crate::mir::interpret::InterpError::Unsupported(
             $crate::mir::interpret::UnsupportedOpInfo::$($tt)*
diff --git a/src/librustc/mir/interpret/pointer.rs b/src/librustc/mir/interpret/pointer.rs
@@ -196,7 +196,7 @@ impl<'tcx, Tag> Pointer<Tag> {
         msg: CheckInAllocMsg,
     ) -> InterpResult<'tcx, ()> {
         if self.offset > allocation_size {
-            throw_err!(PointerOutOfBounds { ptr: self.erase_tag(), msg, allocation_size })
+            throw_err_unsup!(PointerOutOfBounds { ptr: self.erase_tag(), msg, allocation_size })
         } else {
             Ok(())
         }
diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs
@@ -360,7 +360,7 @@ impl<'tcx, Tag> Scalar<Tag> {
                 Scalar::check_data(data, size);
                 Ok(data)
             }
-            Scalar::Ptr(_) => throw_err!(ReadPointerAsBytes),
+            Scalar::Ptr(_) => throw_err_unsup!(ReadPointerAsBytes),
         }
     }
 
@@ -373,8 +373,8 @@ impl<'tcx, Tag> Scalar<Tag> {
     #[inline]
     pub fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
         match self {
-            Scalar::Raw { data: 0, .. } => throw_err!(InvalidNullPointerUsage),
-            Scalar::Raw { .. } => throw_err!(ReadBytesAsPointer),
+            Scalar::Raw { data: 0, .. } => throw_err_unsup!(InvalidNullPointerUsage),
+            Scalar::Raw { .. } => throw_err_unsup!(ReadBytesAsPointer),
             Scalar::Ptr(p) => Ok(p),
         }
     }
@@ -406,15 +406,15 @@ impl<'tcx, Tag> Scalar<Tag> {
         match self {
             Scalar::Raw { data: 0, size: 1 } => Ok(false),
             Scalar::Raw { data: 1, size: 1 } => Ok(true),
-            _ => throw_err!(InvalidBool),
+            _ => throw_err_unsup!(InvalidBool),
         }
     }
 
     pub fn to_char(self) -> InterpResult<'tcx, char> {
         let val = self.to_u32()?;
         match ::std::char::from_u32(val) {
             Some(c) => Ok(c),
-            None => throw_err!(InvalidChar(val as u128)),
+            None => throw_err_unsup!(InvalidChar(val as u128)),
         }
     }
 
@@ -537,7 +537,7 @@ impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
     pub fn not_undef(self) -> InterpResult<'static, Scalar<Tag>> {
         match self {
             ScalarMaybeUndef::Scalar(scalar) => Ok(scalar),
-            ScalarMaybeUndef::Undef => throw_err!(ReadUndefBytes(Size::from_bytes(0))),
+            ScalarMaybeUndef::Undef => throw_err_unsup!(ReadUndefBytes(Size::from_bytes(0))),
         }
     }
 
diff --git a/src/librustc_mir/const_eval.rs b/src/librustc_mir/const_eval.rs
@@ -352,7 +352,9 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                     ecx.goto_block(ret)?; // fully evaluated and done
                     Ok(None)
                 } else {
-                    throw_err!(MachineError(format!("calling non-const function `{}`", instance)))
+                    throw_err_unsup!(
+                        MachineError(format!("calling non-const function `{}`", instance))
+                    )
                 };
             }
         }
@@ -412,7 +414,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
         _tcx: TyCtxt<'tcx>,
         _def_id: DefId,
     ) -> InterpResult<'tcx, Cow<'tcx, Allocation<Self::PointerTag>>> {
-        throw_err!(ReadForeignStatic)
+        throw_err_unsup!(ReadForeignStatic)
     }
 
     #[inline(always)]
diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs
@@ -199,7 +199,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             },
 
             // Casts to bool are not permitted by rustc, no need to handle them here.
-            _ => throw_err!(Unimplemented(format!("int to {:?} cast", dest_layout.ty))),
+            _ => throw_err_unsup!(Unimplemented(format!("int to {:?} cast", dest_layout.ty))),
         }
     }
 
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
@@ -135,7 +135,7 @@ pub enum LocalValue<Tag=(), Id=AllocId> {
 impl<'tcx, Tag: Copy + 'static> LocalState<'tcx, Tag> {
     pub fn access(&self) -> InterpResult<'tcx, Operand<Tag>> {
         match self.value {
-            LocalValue::Dead => throw_err!(DeadLocal),
+            LocalValue::Dead => throw_err_unsup!(DeadLocal),
             LocalValue::Uninitialized =>
                 bug!("The type checker should prevent reading from a never-written local"),
             LocalValue::Live(val) => Ok(val),
@@ -148,7 +148,7 @@ impl<'tcx, Tag: Copy + 'static> LocalState<'tcx, Tag> {
         &mut self,
     ) -> InterpResult<'tcx, Result<&mut LocalValue<Tag>, MemPlace<Tag>>> {
         match self.value {
-            LocalValue::Dead => throw_err!(DeadLocal),
+            LocalValue::Dead => throw_err_unsup!(DeadLocal),
             LocalValue::Live(Operand::Indirect(mplace)) => Ok(Err(mplace)),
             ref mut local @ LocalValue::Live(Operand::Immediate(_)) |
             ref mut local @ LocalValue::Uninitialized => {
@@ -346,7 +346,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             ty::InstanceDef::Item(def_id) => if self.tcx.is_mir_available(did) {
                 Ok(self.tcx.optimized_mir(did))
             } else {
-                throw_err!(NoMirFor(self.tcx.def_path_str(def_id)))
+                throw_err_unsup!(NoMirFor(self.tcx.def_path_str(def_id)))
             },
             _ => Ok(self.tcx.instance_mir(instance)),
         }
diff --git a/src/librustc_mir/interpret/intern.rs b/src/librustc_mir/interpret/intern.rs
@@ -328,7 +328,7 @@ pub fn intern_const_alloc_recursive(
             }
         } else if ecx.memory().dead_alloc_map.contains_key(&alloc_id) {
             // dangling pointer
-            return throw_err!(
+            return throw_err_unsup!(
                 ValidationFailure("encountered dangling pointer in final constant".into())
             )
         }
diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs
@@ -104,7 +104,9 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 };
                 let out_val = if intrinsic_name.ends_with("_nonzero") {
                     if bits == 0 {
-                        return throw_err!(Intrinsic(format!("{} called on 0", intrinsic_name)));
+                        return throw_err_unsup!(
+                            Intrinsic(format!("{} called on 0", intrinsic_name))
+                        );
                     }
                     numeric_intrinsic(intrinsic_name.trim_end_matches("_nonzero"), bits, kind)?
                 } else {
@@ -190,7 +192,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 if overflowed {
                     let layout = self.layout_of(substs.type_at(0))?;
                     let r_val =  r.to_scalar()?.to_bits(layout.size)?;
-                    return throw_err!(Intrinsic(
+                    return throw_err_unsup!(Intrinsic(
                         format!("Overflowing shift by {} in {}", r_val, intrinsic_name),
                     ));
                 }
diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs
@@ -251,6 +251,6 @@ pub trait Machine<'mir, 'tcx>: Sized {
         _mem: &Memory<'mir, 'tcx, Self>,
         _ptr: Pointer<Self::PointerTag>,
     ) -> InterpResult<'tcx, u64> {
-        throw_err!(ReadPointerAsBytes)
+        throw_err_unsup!(ReadPointerAsBytes)
     }
 }
diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
@@ -66,7 +66,7 @@ impl<'tcx, Other> FnVal<'tcx, Other> {
         match self {
             FnVal::Instance(instance) =>
                 Ok(instance),
-            FnVal::Other(_) => throw_err!(MachineError(format!(
+            FnVal::Other(_) => throw_err_unsup!(MachineError(format!(
                 "Expected instance function pointer, got 'other' pointer"
             ))),
         }
@@ -202,7 +202,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         kind: MemoryKind<M::MemoryKinds>,
     ) -> InterpResult<'tcx, Pointer<M::PointerTag>> {
         if ptr.offset.bytes() != 0 {
-            return throw_err!(ReallocateNonBasePtr);
+            return throw_err_unsup!(ReallocateNonBasePtr);
         }
 
         // For simplicities' sake, we implement reallocate as "alloc, copy, dealloc".
@@ -243,38 +243,40 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         trace!("deallocating: {}", ptr.alloc_id);
 
         if ptr.offset.bytes() != 0 {
-            return throw_err!(DeallocateNonBasePtr);
+            return throw_err_unsup!(DeallocateNonBasePtr);
         }
 
         let (alloc_kind, mut alloc) = match self.alloc_map.remove(&ptr.alloc_id) {
             Some(alloc) => alloc,
             None => {
                 // Deallocating static memory -- always an error
                 return match self.tcx.alloc_map.lock().get(ptr.alloc_id) {
-                    Some(GlobalAlloc::Function(..)) => throw_err!(DeallocatedWrongMemoryKind(
+                    Some(GlobalAlloc::Function(..)) => throw_err_unsup!(DeallocatedWrongMemoryKind(
                         "function".to_string(),
                         format!("{:?}", kind),
                     )),
                     Some(GlobalAlloc::Static(..)) |
-                    Some(GlobalAlloc::Memory(..)) => throw_err!(DeallocatedWrongMemoryKind(
+                    Some(GlobalAlloc::Memory(..)) => throw_err_unsup!(DeallocatedWrongMemoryKind(
                         "static".to_string(),
                         format!("{:?}", kind),
                     )),
-                    None => throw_err!(DoubleFree)
+                    None => throw_err_unsup!(DoubleFree)
                 }
             }
         };
 
         if alloc_kind != kind {
-            return throw_err!(DeallocatedWrongMemoryKind(
+            return throw_err_unsup!(DeallocatedWrongMemoryKind(
                 format!("{:?}", alloc_kind),
                 format!("{:?}", kind),
             ));
         }
         if let Some((size, align)) = old_size_and_align {
             if size.bytes() != alloc.bytes.len() as u64 || align != alloc.align {
                 let bytes = Size::from_bytes(alloc.bytes.len() as u64);
-                return throw_err!(IncorrectAllocationInformation(size, bytes, align, alloc.align));
+                return throw_err_unsup!(
+                    IncorrectAllocationInformation(size, bytes, align, alloc.align)
+                );
             }
         }
 
@@ -319,7 +321,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
             } else {
                 // The biggest power of two through which `offset` is divisible.
                 let offset_pow2 = 1 << offset.trailing_zeros();
-                throw_err!(AlignmentCheckFailed {
+                throw_err_unsup!(AlignmentCheckFailed {
                     has: Align::from_bytes(offset_pow2).unwrap(),
                     required: align,
                 })
@@ -341,7 +343,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                 assert!(size.bytes() == 0);
                 // Must be non-NULL and aligned.
                 if bits == 0 {
-                    return throw_err!(InvalidNullPointerUsage);
+                    return throw_err_unsup!(InvalidNullPointerUsage);
                 }
                 check_offset_align(bits, align)?;
                 None
@@ -362,7 +364,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                     // got picked we might be aligned even if this check fails.
                     // We instead have to fall back to converting to an integer and checking
                     // the "real" alignment.
-                    return throw_err!(AlignmentCheckFailed {
+                    return throw_err_unsup!(AlignmentCheckFailed {
                         has: alloc_align,
                         required: align,
                     });
@@ -413,9 +415,9 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
             Some(GlobalAlloc::Memory(mem)) =>
                 Cow::Borrowed(mem),
             Some(GlobalAlloc::Function(..)) =>
-                return throw_err!(DerefFunctionPointer),
+                return throw_err_unsup!(DerefFunctionPointer),
             None =>
-                return throw_err!(DanglingPointerDeref),
+                return throw_err_unsup!(DanglingPointerDeref),
             Some(GlobalAlloc::Static(def_id)) => {
                 // We got a "lazy" static that has not been computed yet.
                 if tcx.is_foreign_item(def_id) {
@@ -505,11 +507,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
             // to give us a cheap reference.
             let alloc = Self::get_static_alloc(memory_extra, tcx, id)?;
             if alloc.mutability == Mutability::Immutable {
-                return throw_err!(ModifiedConstantMemory);
+                return throw_err_unsup!(ModifiedConstantMemory);
             }
             match M::STATIC_KIND {
                 Some(kind) => Ok((MemoryKind::Machine(kind), alloc.into_owned())),
-                None => throw_err!(ModifiedStatic),
+                None => throw_err_unsup!(ModifiedStatic),
             }
         });
         // Unpack the error type manually because type inference doesn't
@@ -519,7 +521,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
             Ok(a) => {
                 let a = &mut a.1;
                 if a.mutability == Mutability::Immutable {
-                    return throw_err!(ModifiedConstantMemory);
+                    return throw_err_unsup!(ModifiedConstantMemory);
                 }
                 Ok(a)
             }
@@ -548,7 +550,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         if let Ok(_) = self.get_fn_alloc(id) {
             return if let AllocCheck::Dereferencable = liveness {
                 // The caller requested no function pointers.
-                throw_err!(DerefFunctionPointer)
+                throw_err_unsup!(DerefFunctionPointer)
             } else {
                 Ok((Size::ZERO, Align::from_bytes(1).unwrap()))
             };
@@ -579,7 +581,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                     .expect("deallocated pointers should all be recorded in \
                             `dead_alloc_map`"))
             } else {
-                throw_err!(DanglingPointerDeref)
+                throw_err_unsup!(DanglingPointerDeref)
             },
         }
     }
@@ -591,7 +593,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         } else {
             match self.tcx.alloc_map.lock().get(id) {
                 Some(GlobalAlloc::Function(instance)) => Ok(FnVal::Instance(instance)),
-                _ => throw_err!(ExecuteMemory),
+                _ => throw_err_unsup!(ExecuteMemory),
             }
         }
     }
@@ -602,7 +604,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
     ) -> InterpResult<'tcx, FnVal<'tcx, M::ExtraFnVal>> {
         let ptr = self.force_ptr(ptr)?; // We definitely need a pointer value.
         if ptr.offset.bytes() != 0 {
-            return throw_err!(InvalidFunctionPointer);
+            return throw_err_unsup!(InvalidFunctionPointer);
         }
         self.get_fn_alloc(ptr.alloc_id)
     }
@@ -837,7 +839,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                     if (src.offset <= dest.offset && src.offset + size > dest.offset) ||
                         (dest.offset <= src.offset && dest.offset + size > src.offset)
                     {
-                        return throw_err!(Intrinsic(
+                        return throw_err_unsup!(Intrinsic(
                             "copy_nonoverlapping called on overlapping ranges".to_string(),
                         ));
                     }
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
diff --git a/src/librustc_mir/interpret/operator.rs b/src/librustc_mir/interpret/operator.rs
diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs
diff --git a/src/librustc_mir/interpret/step.rs b/src/librustc_mir/interpret/step.rs
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs

Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {`
`244`	`244`	`Ok(&self.get_bytes(cx, ptr, size_with_null)?[..size])`
`245`	`245`	`}`
`246`	`246`	// This includes the case where `offset` is out-of-bounds to begin with.
`247`		`- None => throw_err!(UnterminatedCString(ptr.erase_tag())),`
	`247`	`+ None => throw_err_unsup!(UnterminatedCString(ptr.erase_tag())),`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`
`@@ -446,7 +446,7 @@ impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {`
`446`	`446`	`if self.relocations(cx, ptr, size).is_empty() {`
`447`	`447`	`Ok(())`
`448`	`448`	`} else {`
`449`		`- throw_err!(ReadPointerAsBytes)`
	`449`	`+ throw_err_unsup!(ReadPointerAsBytes)`
`450`	`450`	`}`
`451`	`451`	`}`
`452`	`452`
`@@ -516,7 +516,7 @@ impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {`
`516`	`516`	`self.undef_mask.is_range_defined(`
`517`	`517`	`ptr.offset,`
`518`	`518`	`ptr.offset + size,`
`519`		`- ).or_else(\|idx\| throw_err!(ReadUndefBytes(idx)))`
	`519`	`+ ).or_else(\|idx\| throw_err_unsup!(ReadUndefBytes(idx)))`
`520`	`520`	`}`
`521`	`521`
`522`	`522`	`pub fn mark_definedness(`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ impl<'tcx, Tag> Pointer<Tag> {`
`196`	`196`	`msg: CheckInAllocMsg,`
`197`	`197`	`) -> InterpResult<'tcx, ()> {`
`198`	`198`	`if self.offset > allocation_size {`
`199`		`- throw_err!(PointerOutOfBounds { ptr: self.erase_tag(), msg, allocation_size })`
	`199`	`+ throw_err_unsup!(PointerOutOfBounds { ptr: self.erase_tag(), msg, allocation_size })`
`200`	`200`	`} else {`
`201`	`201`	`Ok(())`
`202`	`202`	`}`
Original file line number	Diff line number	Diff line change
`@@ -360,7 +360,7 @@ impl<'tcx, Tag> Scalar<Tag> {`
`360`	`360`	`Scalar::check_data(data, size);`
`361`	`361`	`Ok(data)`
`362`	`362`	`}`
`363`		`- Scalar::Ptr(_) => throw_err!(ReadPointerAsBytes),`
	`363`	`+ Scalar::Ptr(_) => throw_err_unsup!(ReadPointerAsBytes),`
`364`	`364`	`}`
`365`	`365`	`}`
`366`	`366`
`@@ -373,8 +373,8 @@ impl<'tcx, Tag> Scalar<Tag> {`
`373`	`373`	`#[inline]`
`374`	`374`	`pub fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {`
`375`	`375`	`match self {`
`376`		`- Scalar::Raw { data: 0, .. } => throw_err!(InvalidNullPointerUsage),`
`377`		`- Scalar::Raw { .. } => throw_err!(ReadBytesAsPointer),`
	`376`	`+ Scalar::Raw { data: 0, .. } => throw_err_unsup!(InvalidNullPointerUsage),`
	`377`	`+ Scalar::Raw { .. } => throw_err_unsup!(ReadBytesAsPointer),`
`378`	`378`	`Scalar::Ptr(p) => Ok(p),`
`379`	`379`	`}`
`380`	`380`	`}`
`@@ -406,15 +406,15 @@ impl<'tcx, Tag> Scalar<Tag> {`
`406`	`406`	`match self {`
`407`	`407`	`Scalar::Raw { data: 0, size: 1 } => Ok(false),`
`408`	`408`	`Scalar::Raw { data: 1, size: 1 } => Ok(true),`
`409`		`- _ => throw_err!(InvalidBool),`
	`409`	`+ _ => throw_err_unsup!(InvalidBool),`
`410`	`410`	`}`
`411`	`411`	`}`
`412`	`412`
`413`	`413`	`pub fn to_char(self) -> InterpResult<'tcx, char> {`
`414`	`414`	`let val = self.to_u32()?;`
`415`	`415`	`match ::std::char::from_u32(val) {`
`416`	`416`	`Some(c) => Ok(c),`
`417`		`- None => throw_err!(InvalidChar(val as u128)),`
	`417`	`+ None => throw_err_unsup!(InvalidChar(val as u128)),`
`418`	`418`	`}`
`419`	`419`	`}`
`420`	`420`
`@@ -537,7 +537,7 @@ impl<'tcx, Tag> ScalarMaybeUndef<Tag> {`
`537`	`537`	`pub fn not_undef(self) -> InterpResult<'static, Scalar<Tag>> {`
`538`	`538`	`match self {`
`539`	`539`	`ScalarMaybeUndef::Scalar(scalar) => Ok(scalar),`
`540`		`- ScalarMaybeUndef::Undef => throw_err!(ReadUndefBytes(Size::from_bytes(0))),`
	`540`	`+ ScalarMaybeUndef::Undef => throw_err_unsup!(ReadUndefBytes(Size::from_bytes(0))),`
`541`	`541`	`}`
`542`	`542`	`}`
`543`	`543`
Original file line number	Diff line number	Diff line change
`@@ -352,7 +352,9 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,`
`352`	`352`	`ecx.goto_block(ret)?; // fully evaluated and done`
`353`	`353`	`Ok(None)`
`354`	`354`	`} else {`
`355`		- throw_err!(MachineError(format!("calling non-const function `{}`", instance)))
	`355`	`+ throw_err_unsup!(`
	`356`	+ MachineError(format!("calling non-const function `{}`", instance))
	`357`	`+ )`
`356`	`358`	`};`
`357`	`359`	`}`
`358`	`360`	`}`
`@@ -412,7 +414,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,`
`412`	`414`	`_tcx: TyCtxt<'tcx>,`
`413`	`415`	`_def_id: DefId,`
`414`	`416`	`) -> InterpResult<'tcx, Cow<'tcx, Allocation<Self::PointerTag>>> {`
`415`		`- throw_err!(ReadForeignStatic)`
	`417`	`+ throw_err_unsup!(ReadForeignStatic)`
`416`	`418`	`}`
`417`	`419`
`418`	`420`	`#[inline(always)]`
Original file line number	Diff line number	Diff line change
`@@ -199,7 +199,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {`
`199`	`199`	`},`
`200`	`200`
`201`	`201`	`// Casts to bool are not permitted by rustc, no need to handle them here.`
`202`		`- _ => throw_err!(Unimplemented(format!("int to {:?} cast", dest_layout.ty))),`
	`202`	`+ _ => throw_err_unsup!(Unimplemented(format!("int to {:?} cast", dest_layout.ty))),`
`203`	`203`	`}`
`204`	`204`	`}`
`205`	`205`
Original file line number	Diff line number	Diff line change
`@@ -328,7 +328,7 @@ pub fn intern_const_alloc_recursive(`
`328`	`328`	`}`
`329`	`329`	`} else if ecx.memory().dead_alloc_map.contains_key(&alloc_id) {`
`330`	`330`	`// dangling pointer`
`331`		`- return throw_err!(`
	`331`	`+ return throw_err_unsup!(`
`332`	`332`	`ValidationFailure("encountered dangling pointer in final constant".into())`
`333`	`333`	`)`
`334`	`334`	`}`