Give warning if control might right reach std::intrinsics::unreachable (facebookexperimental#25)

Author: Herman Venter

.codecov.yml

@@ -1,3 +1,8 @@
 ignore:
   - tests/.*
-  - src/main.rs
+  - src/main.rs
+
+coverage:
+  range: 60..85
+  round: down
+  precision: 0

.travis.yml

@@ -17,7 +17,7 @@ before_script:
 # install linter
 - rustup component add clippy-preview
 # install code coverage tool
-- RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install cargo-tarpaulin || true
+- RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --force cargo-tarpaulin || true
 
 script:
 # Exit immediately if a command exits with a non-zero status.
@@ -37,6 +37,6 @@ script:
 - RUSTC_WRAPPER=mirai cargo build
 - cargo uninstall mirai
 - cargo clean -p mirai
-- cargo tarpaulin -v --skip-clean --out Xml || true
+- cargo tarpaulin -v --out Xml || true
 - bash <(curl -s https://codecov.io/bash)
 

src/callbacks.rs

@@ -116,14 +116,15 @@ impl<'a> CompilerCalls<'a> for MiraiCallbacks {
 /// At this point the compiler is ready to tell us all it knows and we can proceed to do abstract
 /// interpretation of all of the functions that will end up in the compiler output.
 fn after_analysis(state: &mut driver::CompileState, output_directory: &mut PathBuf) {
+    let session = state.session;
     let tcx = state.tcx.unwrap();
     output_directory.set_file_name(".summary_store");
     output_directory.set_extension("rocksdb");
     let summary_store_path = String::from(output_directory.to_str().unwrap());
     info!("storing summaries at {}", summary_store_path);
     let mut persistent_summary_cache =
         summaries::PersistentSummaryCache::new(&tcx, summary_store_path);
-    let mut constant_value_cache = ConstantValueCache::new();
+    let mut constant_value_cache = ConstantValueCache::default();
     for def_id in tcx.body_owners() {
         {
             let name = persistent_summary_cache.get_summary_key_for(def_id);
@@ -139,6 +140,7 @@ fn after_analysis(state: &mut driver::CompileState, output_directory: &mut PathB
         let mut unwind_condition: Option<AbstractValue> = None;
         {
             let mut mir_visitor = MirVisitor {
+                session,
                 tcx,
                 def_id,
                 mir,

src/constant_value.rs

@@ -4,8 +4,10 @@
 // LICENSE file in the root directory of this source tree.
 
 use rustc::hir::def_id::DefId;
+use rustc::ty::TyCtxt;
 use std::collections::HashMap;
 use summaries::PersistentSummaryCache;
+use utils::is_rust_intrinsic;
 
 /// Abstracts over constant values referenced in MIR and adds information
 /// that is useful for the abstract interpreter. More importantly, this
@@ -29,12 +31,13 @@ impl ConstantValue {
     /// Returns a constant value that is a reference to a function
     pub fn for_function(
         def_id: DefId,
+        tcx: &TyCtxt,
         summary_cache: &mut PersistentSummaryCache,
     ) -> ConstantValue {
         let summary_cache_key = summary_cache.get_summary_key_for(def_id);
         // todo: include the def_id in the result
         ConstantValue::Function {
-            is_intrinsic: false,
+            is_intrinsic: is_rust_intrinsic(def_id, tcx),
             summary_cache_key: summary_cache_key.to_owned(),
         }
     }
@@ -59,11 +62,12 @@ impl ConstantValueCache {
     pub fn get_function_constant_for(
         &mut self,
         def_id: DefId,
+        tcx: &TyCtxt,
         summary_cache: &mut PersistentSummaryCache,
     ) -> &ConstantValue {
         self.cache
             .entry(def_id)
-            .or_insert_with(|| ConstantValue::for_function(def_id, summary_cache))
+            .or_insert_with(|| ConstantValue::for_function(def_id, tcx, summary_cache))
     }
 
     /// Does an expensive check to see if the given function is std::intrinsics::unreachable.
@@ -84,7 +88,7 @@ impl ConstantValueCache {
             if result {
                 self.std_intrinsics_unreachable_function = Some(fun.clone());
             };
-            true
+            result
         })
     }
 }

src/visitors.rs

@@ -7,14 +7,16 @@ use abstract_domains::{AbstractDomains, ExpressionDomain};
 use abstract_value::{AbstractValue, Path};
 use constant_value::{ConstantValue, ConstantValueCache};
 use rpds::{HashTrieMap, List};
-use rustc::ty::{Const, Ty, TyCtxt, TyKind};
+use rustc::session::Session;
+use rustc::ty::{Const, Ty, TyCtxt, TyKind, UserTypeAnnotationIndex};
 use rustc::{hir, mir};
 use std::borrow::Borrow;
 use summaries::PersistentSummaryCache;
 use syntax_pos;
 
 /// Holds the state for the MIR test visitor.
 pub struct MirVisitor<'a, 'b: 'a, 'tcx: 'b> {
+    pub session: &'tcx Session,
     pub tcx: TyCtxt<'b, 'tcx, 'tcx>,
     pub def_id: hir::def_id::DefId,
     pub mir: &'a mir::Mir<'tcx>,
@@ -276,7 +278,20 @@ impl<'a, 'b: 'a, 'tcx: 'b> MirVisitor<'a, 'b, 'tcx> {
         from_hir_call: bool,
     ) {
         debug!("default visit_call(func: {:?}, args: {:?}, destination: {:?}, cleanup: {:?}, from_hir_call: {:?})", func, args, destination, cleanup, from_hir_call);
-        self.visit_operand(func);
+        let func_to_call = self.visit_operand(func);
+        if let ExpressionDomain::CompileTimeConstant(fun) = func_to_call.value.expression_domain {
+            if self
+                .constant_value_cache
+                .check_if_std_intrinsics_unreachable_function(&fun)
+            {
+                let span = self.current_span;
+                let mut err = self.session.struct_span_warn(
+                    span,
+                    "Control might reach a call to std::intrinsics::unreachable",
+                );
+                err.emit();
+            }
+        }
     }
 
     /// Jump to the target if the condition has the expected value,
@@ -474,7 +489,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> MirVisitor<'a, 'b, 'tcx> {
     fn visit_constant(
         &mut self,
         ty: Ty,
-        user_ty: Option<mir::UserTypeAnnotation>,
+        user_ty: Option<UserTypeAnnotationIndex>,
         literal: &Const,
     ) -> &ConstantValue {
         debug!(
@@ -498,8 +513,10 @@ impl<'a, 'b: 'a, 'tcx: 'b> MirVisitor<'a, 'b, 'tcx> {
     /// let bar = foo; // bar: fn() -> i32 {foo}
     /// ```
     fn visit_function_reference(&mut self, def_id: hir::def_id::DefId) -> &ConstantValue {
-        &mut self
-            .constant_value_cache
-            .get_function_constant_for(def_id, &mut self.summary_cache)
+        &mut self.constant_value_cache.get_function_constant_for(
+            def_id,
+            &self.tcx,
+            &mut self.summary_cache,
+        )
     }
 }

tests/run-pass/unreachable.rs

@@ -1,3 +1,11 @@
+// Copyright (c) Facebook, Inc. and its affiliates.
+//
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+//
+
+// A test that calls std::intrinsics::unreachable unconditionally.
+
 #![feature(core_intrinsics)]
 #![allow(unused)]