Skeleton and initial support for proof-carrying code.

cranelift/codegen/meta/src/shared/settings.rs

@@ -63,6 +63,15 @@ pub(crate) fn define() -> SettingGroup {
  true,
  );
 
+ settings.add_bool(
+ "enable_pcc",
+ "Enable proof-carrying code translation validation.",
+ r#"
+ This adds a proof-carrying code mode. TODO ADD MORE
+ "#,
+ false,
+ );
+
  // Note that Cranelift doesn't currently need an is_pie flag, because PIE is
  // just PIC where symbols can't be pre-empted, which can be expressed with the
  // `colocated` flag on external functions and global values.

cranelift/codegen/src/context.rs

@@ -237,6 +237,8 @@ impl Context {
  /// Run the verifier on the function.
  ///
  /// Also check that the dominator tree and control flow graph are consistent with the function.
+ ///
+ /// TODO: rename to "CLIF validate" or similar.
  pub fn verify<'a, FOI: Into<FlagsOrIsa<'a>>>(&self, fisa: FOI) -> VerifierResult<()> {
  let mut errors = VerifierErrors::default();
  let _ = verify_context(&self.func, &self.cfg, &self.domtree, fisa, &mut errors);

cranelift/codegen/src/ir/dfg.rs

@@ -5,6 +5,7 @@ use crate::ir;
 use crate::ir::builder::ReplaceBuilder;
 use crate::ir::dynamic_type::{DynamicTypeData, DynamicTypes};
 use crate::ir::instructions::{CallInfo, InstructionData};
+use crate::ir::pcc::Fact;
 use crate::ir::{
  types, Block, BlockCall, ConstantData, ConstantPool, DynamicType, ExtFuncData, FuncRef,
  Immediate, Inst, JumpTables, RelSourceLoc, SigRef, Signature, Type, Value,
@@ -125,6 +126,9 @@ pub struct DataFlowGraph {
  /// Primary value table with entries for all values.
  values: PrimaryMap<Value, ValueDataPacked>,
 
+ /// Facts: proof-carrying-code assertions about values.
+ pub facts: SecondaryMap<Value, Option<Fact>>,
+
  /// Function signature table. These signatures are referenced by indirect call instructions as
  /// well as the external function references.
  pub signatures: PrimaryMap<SigRef, Signature>,
@@ -158,6 +162,7 @@ impl DataFlowGraph {
  dynamic_types: DynamicTypes::new(),
  value_lists: ValueListPool::new(),
  values: PrimaryMap::new(),
+ facts: SecondaryMap::new(),
  signatures: PrimaryMap::new(),
  old_signatures: SecondaryMap::new(),
  ext_funcs: PrimaryMap::new(),

cranelift/codegen/src/ir/memflags.rs

@@ -6,10 +6,19 @@ use core::fmt;
 use serde_derive::{Deserialize, Serialize};
 
 enum FlagBit {
+ /// Guaranteed not to trap. This may enable additional
+ /// optimizations to be performed.
  Notrap,
+ /// Guaranteed to use "natural alignment" for the given type. This
+ /// may enable better instruction selection.
  Aligned,
+ /// A load that reads data in memory that does not change for the
+ /// duration of the function's execution. This may enable
+ /// additional optimizations to be performed.
  Readonly,
+ /// Load multi-byte values from memory in a little-endian format.
  LittleEndian,
+ /// Load multi-byte values from memory in a big-endian format.
  BigEndian,
  /// Accesses only the "heap" part of abstract state. Used for
  /// alias analysis. Mutually exclusive with "table" and "vmctx".
@@ -20,10 +29,15 @@ enum FlagBit {
  /// Accesses only the "vmctx" part of abstract state. Used for
  /// alias analysis. Mutually exclusive with "heap" and "table".
  Vmctx,
+ /// Check this load or store for safety when using the
+ /// proof-carrying-code framework. The address must have a
+ /// `PointsTo` fact attached with a sufficiently large valid range
+ /// for the accessed size.
+ Safe,
 }
 
-const NAMES: [&str; 8] = [
- "notrap", "aligned", "readonly", "little", "big", "heap", "table", "vmctx",
+const NAMES: [&str; 9] = [
+ "notrap", "aligned", "readonly", "little", "big", "heap", "table", "vmctx", "safe",
 ];
 
 /// Endianness of a memory access.
@@ -48,7 +62,7 @@ pub enum Endianness {
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct MemFlags {
- bits: u8,
+ bits: u16,
 }
 
 impl MemFlags {
@@ -265,6 +279,32 @@ impl MemFlags {
  self.set_vmctx();
  self
  }
+
+ /// Test if the `safe` bit is set.
+ ///
+ /// Loads and stores with this flag are verified to access
+ /// pointers only with a validated `PointsTo` fact attached, and
+ /// with that fact validated, when using the proof-carrying-code
+ /// framework. If initial facts on program inputs are correct
+ /// (i.e., correctly denote the shape and types of data structures
+ /// in memory), and if PCC validates the compiled output, then all
+ /// `safe`-marked memory accesses are guaranteed (up to the
+ /// checker's correctness) to access valid memory. This can be
+ /// used to ensure memory safety and sandboxing.
+ pub fn safe(self) -> bool {
+ self.read(FlagBit::Safe)
+ }
+
+ /// Set the `safe` bit.
+ pub fn set_safe(&mut self) {
+ self.set(FlagBit::Safe);
+ }
+
+ /// Set the `safe` bit, returning new flags.
+ pub fn with_safe(mut self) -> Self {
+ self.set_safe();
+ self
+ }
 }
 
 impl fmt::Display for MemFlags {

cranelift/codegen/src/ir/mod.rs

@@ -18,6 +18,7 @@ pub(crate) mod known_symbol;
 pub mod layout;
 pub(crate) mod libcall;
 mod memflags;
+pub mod pcc;
 mod progpoint;
 mod sourceloc;
 pub mod stackslot;