Merge branch 'master' into kkysen/analyze-string-casts

Author: kkysen

c2rust-analyze/src/main.rs

@@ -23,7 +23,8 @@ use crate::dataflow::DataflowConstraints;
 use crate::equiv::{GlobalEquivSet, LocalEquivSet};
 use crate::labeled_ty::LabeledTyCtxt;
 use crate::log::init_logger;
-use crate::util::Callee;
+use crate::panic_detail::PanicDetail;
+use crate::util::{Callee, TestAttr};
 use context::AdtMetadataTable;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -38,6 +39,7 @@ use rustc_span::Span;
 use std::collections::{HashMap, HashSet};
 use std::env;
 use std::fmt::{Debug, Display};
+use std::iter;
 use std::ops::{Deref, DerefMut, Index};
 use std::panic::AssertUnwindSafe;
 
@@ -493,6 +495,30 @@ fn run(tcx: TyCtxt) {
         info.lasn.set(lasn);
     }
 
+    // For testing, putting #[c2rust_analyze_test::fixed_signature] on a function makes all
+    // pointers in its signature FIXED.
+    for &ldid in &all_fn_ldids {
+        if !util::has_test_attr(tcx, ldid, TestAttr::FixedSignature) {
+            continue;
+        }
+        let lsig = match gacx.fn_sigs.get(&ldid.to_def_id()) {
+            Some(x) => x,
+            None => continue,
+        };
+        make_sig_fixed(&mut gasn, lsig);
+    }
+
+    // For testing, putting #[c2rust_analyze_test::fail_analysis] on a function marks it as failed.
+    for &ldid in &all_fn_ldids {
+        if !util::has_test_attr(tcx, ldid, TestAttr::FailAnalysis) {
+            continue;
+        }
+        gacx.mark_fn_failed(
+            ldid.to_def_id(),
+            PanicDetail::new("explicit fail_analysis for testing".to_owned()),
+        );
+    }
+
     eprintln!("=== ADT Metadata ===");
     eprintln!("{:?}", gacx.adt_metadata);
 
@@ -597,6 +623,10 @@ fn run(tcx: TyCtxt) {
 
         eprintln!();
 
+        if util::has_test_attr(tcx, ldid, TestAttr::SkipRewrite) {
+            continue;
+        }
+
         let r = panic_detail::catch_unwind(AssertUnwindSafe(|| {
             let hir_body_id = tcx.hir().body_owned_by(ldid);
             let expr_rewrites = rewrite::gen_expr_rewrites(&acx, &asn, &mir, hir_body_id);
@@ -738,6 +768,21 @@ impl<'tcx> AssignPointerIds<'tcx> for AnalysisCtxt<'_, 'tcx> {
     }
 }
 
+fn make_ty_fixed(gasn: &mut GlobalAssignment, lty: LTy) {
+    for lty in lty.iter() {
+        let ptr = lty.label;
+        if !ptr.is_none() {
+            gasn.flags[ptr].insert(FlagSet::FIXED);
+        }
+    }
+}
+
+fn make_sig_fixed(gasn: &mut GlobalAssignment, lsig: &LFnSig) {
+    for lty in lsig.inputs.iter().copied().chain(iter::once(lsig.output)) {
+        make_ty_fixed(gasn, lty);
+    }
+}
+
 fn describe_local(tcx: TyCtxt, decl: &LocalDecl) -> String {
     let mut span = decl.source_info.span;
     if let Some(ref info) = decl.local_info {

c2rust-analyze/src/rewrite/expr/hir_op.rs

@@ -197,6 +197,22 @@ impl<'a, 'tcx> HirRewriteVisitor<'a, 'tcx> {
                     .unwrap_or_else(|err| panic_location_error(err, "Assignment statement"));
                 locations.push(assign_loc)
             }
+            hir::ExprKind::Cast(..) => {
+                let r = self.find_sole_location_matching(
+                    ex.span,
+                    |stmt| {
+                        let rv = match stmt.kind {
+                            mir::StatementKind::Assign(ref x) => &x.1,
+                            _ => return false,
+                        };
+                        matches!(rv, mir::Rvalue::Cast(..))
+                    },
+                    |_term| false,
+                );
+                if let Ok(assign_loc) = r {
+                    locations.push(assign_loc);
+                }
+            }
             _ => eprintln!("warning: find_primary_location: unsupported expr {:?}", ex),
         }
 
@@ -320,6 +336,21 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for HirRewriteVisitor<'a, 'tcx> {
                     Rewrite::Ref(Box::new(self.get_subexpr(ex, 0)), mutbl_from_bool(*mutbl))
                 }
 
+                mir_op::RewriteKind::CastRefToRaw { mutbl } => {
+                    // `addr_of!(*p)` is cleaner than `p as *const _`; we don't know the pointee
+                    // type here, so we can't emit `p as *const T`.
+                    let rw_pl = Rewrite::Deref(Box::new(hir_rw));
+                    Rewrite::AddrOf(Box::new(rw_pl), mutbl_from_bool(*mutbl))
+                }
+                mir_op::RewriteKind::CastRawToRaw { to_mutbl } => {
+                    let method = if *to_mutbl { "cast_mut" } else { "cast_const" };
+                    Rewrite::MethodCall(method.to_string(), Box::new(hir_rw), vec![])
+                }
+                mir_op::RewriteKind::UnsafeCastRawToRef { mutbl } => {
+                    let rw_pl = Rewrite::Deref(Box::new(hir_rw));
+                    Rewrite::Ref(Box::new(rw_pl), mutbl_from_bool(*mutbl))
+                }
+
                 mir_op::RewriteKind::CellNew => {
                     // `x` to `Cell::new(x)`
                     Rewrite::Call("std::cell::Cell::new".to_string(), vec![Rewrite::Identity])
@@ -341,6 +372,14 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for HirRewriteVisitor<'a, 'tcx> {
                     let rhs = self.get_subexpr(ex, 1);
                     Rewrite::MethodCall("set".to_string(), Box::new(lhs), vec![rhs])
                 }
+
+                mir_op::RewriteKind::CellFromMut => {
+                    // `x` to `Cell::from_mut(x)`
+                    Rewrite::Call(
+                        "std::cell::Cell::from_mut".to_string(),
+                        vec![Rewrite::Identity],
+                    )
+                }
             }
         };
 

c2rust-analyze/src/rewrite/expr/mir_op.rs

@@ -12,6 +12,7 @@ use crate::panic_detail;
 use crate::pointer_id::PointerTable;
 use crate::type_desc::{self, Ownership, Quantity, TypeDesc};
 use crate::util::{ty_callee, Callee};
+use log::*;
 use rustc_ast::Mutability;
 use rustc_middle::mir::{
     BasicBlock, Body, Location, Operand, Place, Rvalue, Statement, StatementKind, Terminator,
@@ -51,13 +52,24 @@ pub enum RewriteKind {
     RemoveAsPtr,
     /// Replace &raw with & or &raw mut with &mut
     RawToRef { mutbl: bool },
+
+    /// Cast `&T` to `*const T` or `&mut T` to `*mut T`.
+    CastRefToRaw { mutbl: bool },
+    /// Cast `*const T` to `*mut T` or vice versa.  If `to_mutbl` is true, we are casting to
+    /// `*mut T`; otherwise, we're casting to `*const T`.
+    CastRawToRaw { to_mutbl: bool },
+    /// Cast `*const T` to `& T` or `*mut T` to `&mut T`.
+    UnsafeCastRawToRef { mutbl: bool },
+
     /// Replace `y` in `let x = y` with `Cell::new(y)`, i.e. `let x = Cell::new(y)`
     /// TODO: ensure `y` implements `Copy`
     CellNew,
     /// Replace `*y` with `Cell::get(y)` where `y` is a pointer
     CellGet,
     /// Replace `*y = x` with `Cell::set(x)` where `y` is a pointer
     CellSet,
+    /// Wrap `&mut T` in `Cell::from_mut` to get `&Cell<T>`.
+    CellFromMut,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -257,11 +269,9 @@ impl<'a, 'tcx> ExprRewriteVisitor<'a, 'tcx> {
                 match ty_callee(tcx, func_ty) {
                     Callee::PtrOffset { .. } => {
                         self.visit_ptr_offset(&args[0], pl_ty);
-                        return;
                     }
                     Callee::SliceAsPtr { elem_ty, .. } => {
                         self.visit_slice_as_ptr(elem_ty, &args[0], pl_ty);
-                        return;
                     }
                     _ => {}
                 }
@@ -424,10 +434,9 @@ impl<'a, 'tcx> ExprRewriteVisitor<'a, 'tcx> {
 
         self.emit(RewriteKind::OffsetSlice { mutbl });
 
-        // If the result is `Single`, also insert an upcast.
-        if result_desc.qty == Quantity::Single {
-            self.emit(RewriteKind::SliceFirst { mutbl });
-        }
+        // The `OffsetSlice` operation returns something of the same type as its input.  Afterward,
+        // we must cast the result to the `result_ty`/`result_desc`.
+        self.emit_cast_desc_desc(arg_expect_desc, result_desc);
     }
 
     fn visit_slice_as_ptr(&mut self, elem_ty: Ty<'tcx>, op: &Operand<'tcx>, result_lty: LTy<'tcx>) {
@@ -468,38 +477,172 @@ impl<'a, 'tcx> ExprRewriteVisitor<'a, 'tcx> {
     }
 
     fn emit_cast_desc_desc(&mut self, from: TypeDesc<'tcx>, to: TypeDesc<'tcx>) {
+        let orig_from = from;
+        let mut from = orig_from;
+
+        // The `from` and `to` pointee types should only differ in their lifetimes.
         assert_eq!(
             self.acx.tcx().erase_regions(from.pointee_ty),
             self.acx.tcx().erase_regions(to.pointee_ty),
         );
+        // There might still be differences in lifetimes, which we don't care about here.
+        // Overwriting `from.pointee_ty` allows the final `from == to` check to succeed below.
+        from.pointee_ty = to.pointee_ty;
 
         if from == to {
             return;
         }
 
-        let orig_from = from;
-        let mut from = orig_from;
+        // Early `Ownership` casts.  We do certain casts here in hopes of reaching an `Ownership`
+        // on which we can safely adjust `Quantity`.
+        from.own = self.cast_ownership(from, to, true);
+
+        // Safe casts that change `Quantity`.
+        while from.qty != to.qty {
+            // Mutability of `from`.  `None` here means that safe `Quantity` conversions aren't
+            // possible given `from`'s `Ownership`.  For example, we can't convert `Box<[T]>` to
+            // `Box<T>`.
+            let opt_mutbl = match from.own {
+                // Note that `Cell` + `Slice` is `&[Cell<T>]`, not `&Cell<[T]>`, so it can be
+                // handled like any other `&[_]`.
+                Ownership::Imm | Ownership::Cell => Some(false),
+                Ownership::Mut => Some(true),
+                _ => None,
+            };
+            match (from.qty, to.qty) {
+                (Quantity::Array, _) => {
+                    // `Array` goes only to `Slice` directly.  All other `Array` conversions go
+                    // through `Slice` first.
+                    error!("TODO: cast Array to {:?}", to.qty);
+                    from.qty = Quantity::Slice;
+                }
+                // Bidirectional conversions between `Slice` and `OffsetPtr`.
+                (Quantity::Slice, Quantity::OffsetPtr) | (Quantity::OffsetPtr, Quantity::Slice) => {
+                    // Currently a no-op, since `Slice` and `OffsetPtr` are identical.
+                    from.qty = to.qty;
+                }
+                // `Slice` and `OffsetPtr` convert to `Single` the same way.
+                // TODO: when converting to `Ownership::Raw`/`RawMut`, use `slice.as_ptr()` to
+                // avoid panic on 0-length inputs
+                (_, Quantity::Single) => {
+                    let rw = match opt_mutbl {
+                        Some(mutbl) => RewriteKind::SliceFirst { mutbl },
+                        None => break,
+                    };
+                    self.emit(rw);
+                    from.qty = Quantity::Single;
+                }
 
-        if (from.qty, to.qty) == (Quantity::OffsetPtr, Quantity::Slice) {
-            // TODO: emit rewrite
-            from.qty = to.qty;
-        }
+                // Unsupported cases
+                (Quantity::Single, _) => break,
+                (_, Quantity::Array) => break,
 
-        if from.qty == to.qty && (from.own, to.own) == (Ownership::Mut, Ownership::Imm) {
-            self.emit(RewriteKind::MutToImm);
-            from.own = to.own;
+                // Remaining cases are impossible, since `from.qty != to.qty`.
+                (Quantity::Slice, Quantity::Slice) | (Quantity::OffsetPtr, Quantity::OffsetPtr) => {
+                    unreachable!()
+                }
+            }
         }
 
-        // TODO: handle Slice -> Single here instead of special-casing in `offset`
+        // Late `Ownership` casts.
+        from.own = self.cast_ownership(from, to, false);
 
         if from != to {
-            eprintln!(
+            panic!(
                 "unsupported cast kind: {:?} -> {:?} (original input: {:?})",
                 from, to, orig_from
             );
         }
     }
 
+    fn cast_ownership(&mut self, from: TypeDesc, to: TypeDesc, early: bool) -> Ownership {
+        let mut from = from;
+        while from.own != to.own {
+            match self.cast_ownership_one_step(from, to, early) {
+                Some(new_own) => {
+                    from.own = new_own;
+                }
+                None => break,
+            }
+        }
+        from.own
+    }
+
+    fn cast_ownership_one_step(
+        &mut self,
+        from: TypeDesc,
+        to: TypeDesc,
+        early: bool,
+    ) -> Option<Ownership> {
+        match from.own {
+            Ownership::Box => match to.own {
+                Ownership::Raw | Ownership::Imm => {
+                    error!("TODO: cast Box to Imm");
+                    Some(Ownership::Imm)
+                }
+                Ownership::RawMut | Ownership::Mut => {
+                    error!("TODO: cast Box to Mut");
+                    Some(Ownership::Mut)
+                }
+                _ => None,
+            },
+            Ownership::Rc => match to.own {
+                Ownership::Imm | Ownership::Raw | Ownership::RawMut => {
+                    error!("TODO: cast Rc to Imm");
+                    Some(Ownership::Imm)
+                }
+                _ => None,
+            },
+            Ownership::Mut => match to.own {
+                Ownership::Imm | Ownership::Raw => {
+                    self.emit(RewriteKind::MutToImm);
+                    Some(Ownership::Imm)
+                }
+                Ownership::Cell => {
+                    self.emit(RewriteKind::CellFromMut);
+                    Some(Ownership::Cell)
+                }
+                Ownership::RawMut if !early => {
+                    self.emit(RewriteKind::CastRefToRaw { mutbl: true });
+                    Some(Ownership::RawMut)
+                }
+                _ => None,
+            },
+            Ownership::Cell => None,
+            Ownership::Imm => match to.own {
+                Ownership::Raw | Ownership::RawMut if !early => {
+                    self.emit(RewriteKind::CastRefToRaw { mutbl: false });
+                    Some(Ownership::Raw)
+                }
+                _ => None,
+            },
+            Ownership::RawMut => match to.own {
+                // For `RawMut` to `Imm`, we go through `Raw` instead of through `Mut` because
+                // `&mut` adds more implicit constraints under the Rust memory model.
+                Ownership::Raw | Ownership::Imm if !early => {
+                    self.emit(RewriteKind::CastRawToRaw { to_mutbl: false });
+                    Some(Ownership::Raw)
+                }
+                Ownership::Mut if !early => {
+                    self.emit(RewriteKind::UnsafeCastRawToRef { mutbl: true });
+                    Some(Ownership::Mut)
+                }
+                _ => None,
+            },
+            Ownership::Raw => match to.own {
+                Ownership::RawMut | Ownership::Mut if !early => {
+                    self.emit(RewriteKind::CastRawToRaw { to_mutbl: true });
+                    Some(Ownership::RawMut)
+                }
+                Ownership::Imm if !early => {
+                    self.emit(RewriteKind::UnsafeCastRawToRef { mutbl: false });
+                    Some(Ownership::Imm)
+                }
+                _ => None,
+            },
+        }
+    }
+
     fn emit_cast_lty_desc(&mut self, from_lty: LTy<'tcx>, to: TypeDesc<'tcx>) {
         let from = type_desc::perms_to_desc_with_pointee(
             self.acx.tcx(),