link to some websites for UB explanations

Author: RalfJung

src/diagnostics.rs

@@ -9,6 +9,7 @@ pub enum TerminationInfo {
     Exit(i64),
     Abort(Option<String>),
     UnsupportedInIsolation(String),
+    ExperimentalUb { msg: String, url: String }
 }
 
 /// Miri specific diagnostics
@@ -25,7 +26,7 @@ pub fn report_error<'tcx, 'mir>(
     use InterpError::*;
 
     e.print_backtrace();
-    let (title, msg, help) = match e.kind {
+    let (title, msg, helps) = match e.kind {
         MachineStop(info) => {
             let info = info.downcast_ref::<TerminationInfo>().expect("invalid MachineStop payload");
             use TerminationInfo::*;
@@ -37,13 +38,20 @@ pub fn report_error<'tcx, 'mir>(
                     ("abnormal termination", format!("the evaluated program aborted execution: {}", msg)),
                 UnsupportedInIsolation(msg) =>
                     ("unsupported operation", format!("{}", msg)),
+                ExperimentalUb { msg, .. } =>
+                    ("Undefined Behavior", format!("{}", msg)),
             };
-            let help = match info {
+            let helps = match info {
                 UnsupportedInIsolation(_) =>
-                    Some("pass the flag `-Zmiri-disable-isolation` to disable isolation"),
-                _ => None,
+                    vec![format!("pass the flag `-Zmiri-disable-isolation` to disable isolation")],
+                ExperimentalUb { url, .. } =>
+                    vec![
+                        format!("this indicates a potential bug in the program: it performed an invalid operation, but the rules it violated are still experimental"),
+                        format!("see {} for further information", url),
+                    ],
+                _ => vec![],
             };
-            (title, msg, help)
+            (title, msg, helps)
         }
         _ => {
             let (title, msg) = match e.kind {
@@ -56,21 +64,22 @@ pub fn report_error<'tcx, 'mir>(
                 _ =>
                     bug!("This error should be impossible in Miri: {}", e),
             };
-            let help = match e.kind {
+            let helps = match e.kind {
                 Unsupported(UnsupportedOpInfo::NoMirFor(..)) =>
-                    Some("make sure to use a Miri sysroot, which you can prepare with `cargo miri setup`"),
+                    vec![format!("make sure to use a Miri sysroot, which you can prepare with `cargo miri setup`")],
                 Unsupported(_) =>
-                    Some("this is likely not a bug in the program; it indicates that the program performed an operation that the interpreter does not support"),
-                UndefinedBehavior(UndefinedBehaviorInfo::UbExperimental(_)) =>
-                    Some("this indicates a potential bug in the program: it performed an invalid operation, but the rules it violated are still experimental"),
+                    vec![format!("this is likely not a bug in the program; it indicates that the program performed an operation that the interpreter does not support")],
                 UndefinedBehavior(_) =>
-                    Some("this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior"),
-                _ => None,
+                    vec![
+                        format!("this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior"),
+                        format!("see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information"),
+                    ],
+                _ => vec![],
             };
-            (title, msg, help)
+            (title, msg, helps)
         }
     };
-    report_msg(ecx, &format!("{}: {}", title, msg), msg, help, true)
+    report_msg(ecx, &format!("{}: {}", title, msg), msg, &helps, true)
 }
 
 /// Report an error or note (depending on the `error` argument) at the current frame's current statement.
@@ -79,7 +88,7 @@ fn report_msg<'tcx, 'mir>(
     ecx: &InterpCx<'mir, 'tcx, Evaluator<'tcx>>,
     title: &str,
     span_msg: String,
-    help: Option<&str>,
+    helps: &[String],
     error: bool,
 ) -> Option<i64> {
     let span = if let Some(frame) = ecx.stack().last() {
@@ -93,7 +102,7 @@ fn report_msg<'tcx, 'mir>(
         ecx.tcx.sess.diagnostic().span_note_diag(span, title)
     };
     err.span_label(span, span_msg);
-    if let Some(help) = help {
+    for help in helps {
         err.help(help);
     }
     // Add backtrace
@@ -149,7 +158,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     CreatedAlloc(AllocId(id)) =>
                         format!("created allocation with id {}", id),
                 };
-                report_msg(this, "tracking was triggered", msg, None, false);
+                report_msg(this, "tracking was triggered", msg, &[], false);
             }
         });
     }

src/stacked_borrows.rs

@@ -192,6 +192,15 @@ impl GlobalState {
     }
 }
 
+/// Error reporting
+fn err_sb_ub(msg: String) -> InterpError<'static> {
+    // FIXME: use `err_machine_stop!` macro, once that exists.
+    InterpError::MachineStop(Box::new(TerminationInfo::ExperimentalUb {
+        msg,
+        url: format!("https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md"),
+    }))
+}
+
 // # Stacked Borrows Core Begin
 
 /// We need to make at least the following things true:
@@ -272,15 +281,15 @@ impl<'tcx> Stack {
         if let Some(call) = item.protector {
             if global.is_active(call) {
                 if let Some(tag) = tag {
-                    throw_ub!(UbExperimental(format!(
+                    Err(err_sb_ub(format!(
                         "not granting access to tag {:?} because incompatible item is protected: {:?}",
                         tag, item
-                    )));
+                    )))?
                 } else {
-                    throw_ub!(UbExperimental(format!(
+                    Err(err_sb_ub(format!(
                         "deallocating while item is protected: {:?}",
                         item
-                    )));
+                    )))?
                 }
             }
         }
@@ -294,10 +303,10 @@ impl<'tcx> Stack {
 
         // Step 1: Find granting item.
         let granting_idx = self.find_granting(access, tag).ok_or_else(|| {
-            err_ub!(UbExperimental(format!(
+            err_sb_ub(format!(
                 "no item granting {} to tag {:?} found in borrow stack.",
                 access, tag
-            ),))
+            ))
         })?;
 
         // Step 2: Remove incompatible items above them.  Make sure we do not remove protected
@@ -338,10 +347,10 @@ impl<'tcx> Stack {
     fn dealloc(&mut self, tag: Tag, global: &GlobalState) -> InterpResult<'tcx> {
         // Step 1: Find granting item.
         self.find_granting(AccessKind::Write, tag).ok_or_else(|| {
-            err_ub!(UbExperimental(format!(
+            err_sb_ub(format!(
                 "no item granting write access for deallocation to tag {:?} found in borrow stack",
                 tag,
-            )))
+            ))
         })?;
 
         // Step 2: Remove all items.  Also checks for protectors.
@@ -363,10 +372,10 @@ impl<'tcx> Stack {
         // Now we figure out which item grants our parent (`derived_from`) this kind of access.
         // We use that to determine where to put the new item.
         let granting_idx = self.find_granting(access, derived_from)
-            .ok_or_else(|| err_ub!(UbExperimental(format!(
+            .ok_or_else(|| err_sb_ub(format!(
                 "trying to reborrow for {:?}, but parent tag {:?} does not have an appropriate item in the borrow stack",
                 new.perm, derived_from,
-            ))))?;
+            )))?;
 
         // Compute where to put the new item.
         // Either way, we ensure that we insert the new item in a way such that between