diff --git a/c2rust-analyze/src/main.rs b/c2rust-analyze/src/main.rs index fc34383fc6..df69a55679 100644 --- a/c2rust-analyze/src/main.rs +++ b/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 { diff --git a/c2rust-analyze/src/util.rs b/c2rust-analyze/src/util.rs index 7988bd576d..76f9ea8248 100644 --- a/c2rust-analyze/src/util.rs +++ b/c2rust-analyze/src/util.rs @@ -1,8 +1,9 @@ use crate::labeled_ty::LabeledTy; use crate::trivial::IsTrivial; +use rustc_ast::ast::AttrKind; use rustc_const_eval::interpret::Scalar; use rustc_hir::def::DefKind; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_middle::mir::{ BasicBlock, BasicBlockData, Constant, Field, Local, Location, Mutability, Operand, Place, PlaceElem, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, @@ -10,6 +11,7 @@ use rustc_middle::mir::{ use rustc_middle::ty::{ self, AdtDef, DefIdTree, EarlyBinder, Subst, SubstsRef, Ty, TyCtxt, TyKind, UintTy, }; +use rustc_span::symbol::Symbol; use std::fmt::Debug; #[derive(Debug)] @@ -353,3 +355,44 @@ pub fn is_null_const(constant: Constant) -> bool { pub trait PhantomLifetime<'a> {} impl<'a, T: ?Sized> PhantomLifetime<'a> for T {} + +#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] +pub enum TestAttr { + /// `#[c2rust_analyze_test::fixed_signature]`: Mark all pointers in the function signature as + /// [`FIXED`](crate::context::FlagSet::FIXED). + FixedSignature, + /// `#[c2rust_analyze_test::fail_analysis]`: Force an analysis failure for the function. + FailAnalysis, + /// `#[c2rust_analyze_test::skip_rewrite]`: Skip generating rewrites for the function. + SkipRewrite, +} + +impl TestAttr { + pub fn name(self) -> &'static str { + match self { + TestAttr::FixedSignature => "fixed_signature", + TestAttr::FailAnalysis => "fail_analysis", + TestAttr::SkipRewrite => "skip_rewrite", + } + } +} + +pub fn has_test_attr(tcx: TyCtxt, ldid: LocalDefId, attr: TestAttr) -> bool { + let tool_sym = Symbol::intern("c2rust_analyze_test"); + let name_sym = Symbol::intern(attr.name()); + + for attr in tcx.get_attrs_unchecked(ldid.to_def_id()) { + let path = match attr.kind { + AttrKind::Normal(ref item, _) => &item.path, + AttrKind::DocComment(..) => continue, + }; + let (a, b) = match &path.segments[..] { + &[ref a, ref b] => (a, b), + _ => continue, + }; + if a.ident.name == tool_sym && b.ident.name == name_sym { + return true; + } + } + false +} diff --git a/c2rust-analyze/tests/filecheck.rs b/c2rust-analyze/tests/filecheck.rs index 51df9b1b6a..4dac1d337f 100644 --- a/c2rust-analyze/tests/filecheck.rs +++ b/c2rust-analyze/tests/filecheck.rs @@ -54,6 +54,7 @@ define_tests! { offset2, ptrptr1, statics, + test_attrs, trivial, type_annotation_rewrite, } diff --git a/c2rust-analyze/tests/filecheck/test_attrs.rs b/c2rust-analyze/tests/filecheck/test_attrs.rs new file mode 100644 index 0000000000..d1280d0016 --- /dev/null +++ b/c2rust-analyze/tests/filecheck/test_attrs.rs @@ -0,0 +1,24 @@ +#![feature(register_tool)] +#![register_tool(c2rust_analyze_test)] + +// CHECK-LABEL: type assignment for "f": +// CHECK: _0 ({{.*}}: *mut i32): *mut i32 +// CHECK: _1 ({{.*}}: x): *mut i32 +#[c2rust_analyze_test::fixed_signature] +fn f(x: *mut i32) -> *mut i32 { + x +} + +// CHECK-LABEL: type assignment for "g": +// CHECK: _0 ({{.*}}: *mut i32): &i32 +// CHECK: _1 ({{.*}}: x): &i32 +#[c2rust_analyze_test::skip_rewrite] +fn g(x: *mut i32) -> *mut i32 { + x +} + +// CHECK: analysis of DefId({{.*}} ~ test_attrs[{{.*}}]::h) failed: [unknown]: explicit fail_analysis for testing +#[c2rust_analyze_test::fail_analysis] +fn h(x: *mut i32) -> *mut i32 { + x +}