Zero init for common types (rust-lang#1520)

Author: danielsn

cprover_bindings/src/goto_program/expr.rs

@@ -84,6 +84,8 @@ pub enum ExprValue {
     Dereference(Expr),
     /// `1.0`
     DoubleConstant(f64),
+    // {}
+    EmptyUnion,
     /// `1.0f`
     FloatConstant(f32),
     /// `function(arguments)`
@@ -542,6 +544,13 @@ impl Expr {
         Self::double_constant(c)
     }
 
+    pub fn empty_union(typ: Type, st: &SymbolTable) -> Self {
+        assert!(typ.is_union() || typ.is_union_tag());
+        assert!(typ.lookup_components(st).unwrap().is_empty());
+        let typ = typ.aggr_tag().unwrap();
+        expr!(EmptyUnion, typ)
+    }
+
     /// `1.0f`
     pub fn float_constant(c: f32) -> Self {
         expr!(FloatConstant(c), Type::float())
@@ -553,6 +562,18 @@ impl Expr {
         Self::float_constant(c)
     }
 
+    /// `typ x[__CPROVER_infinity()] = >>> {elem} <<<`
+    /// i.e. initilize an infinite sized sparse array.
+    /// This is useful for maps:
+    /// ```
+    /// bool x[__CPROVER_infinity()] = {false};
+    /// x[idx_1] = true;
+    /// if (x[idx_2]) { ... }
+    /// ```
+    pub fn infinite_array_constant(self) -> Self {
+        expr!(ArrayOf { elem: self }, self.typ.clone().infinite_array_of())
+    }
+
     /// `self[index]`
     pub fn index_array(self, index: Expr) -> Self {
         assert!(index.typ.is_integer());
@@ -566,7 +587,7 @@ impl Expr {
     where
         T: Into<BigInt>,
     {
-        assert!(typ.is_integer());
+        assert!(typ.is_integer() || typ.is_bitfield());
         let i = i.into();
         // TODO: <https://github.com/model-checking/kani/issues/996>
         // if i != 0 && i != 1 {
@@ -806,11 +827,12 @@ impl Expr {
         symbol_table: &SymbolTable,
     ) -> Self {
         assert!(
-            typ.is_struct_tag(),
-            "Error in struct_expr; must be given struct_tag.\n\t{:?}\n\t{:?}",
+            typ.is_struct_tag() || typ.is_struct(),
+            "Error in struct_expr; must be given struct.\n\t{:?}\n\t{:?}",
             typ,
             values
         );
+        let typ = typ.aggr_tag().unwrap();
         let fields = typ.lookup_components(symbol_table).unwrap();
         assert_eq!(
             fields.len(),
@@ -869,8 +891,9 @@ impl Expr {
         symbol_table: &SymbolTable,
     ) -> Self {
         let field = field.into();
-        assert!(typ.is_union_tag());
+        assert!(typ.is_union_tag() || typ.is_union());
         assert_eq!(typ.lookup_field_type(field, symbol_table).as_ref(), Some(value.typ()));
+        let typ = typ.aggr_tag().unwrap();
         expr!(Union { value, field }, typ)
     }
 }

cprover_bindings/src/goto_program/symtab_transformer/transformer.rs

@@ -258,6 +258,7 @@ pub trait Transformer: Sized {
             ExprValue::CBoolConstant(value) => self.transform_expr_c_bool_constant(typ, value),
             ExprValue::Dereference(child) => self.transform_expr_dereference(typ, child),
             ExprValue::DoubleConstant(value) => self.transform_expr_double_constant(typ, value),
+            ExprValue::EmptyUnion => self.transform_expr_empty_union(typ),
             ExprValue::FloatConstant(value) => self.transform_expr_float_constant(typ, value),
             ExprValue::FunctionCall { function, arguments } => {
                 self.transform_expr_function_call(typ, function, arguments)
@@ -361,6 +362,11 @@ pub trait Transformer: Sized {
         Expr::double_constant(*value)
     }
 
+    /// Transforms an empty union expr (`{}`)
+    fn transform_expr_empty_union(&mut self, typ: &Type) -> Expr {
+        Expr::empty_union(typ.clone(), self.symbol_table())
+    }
+
     /// Transforms a float constant expr (`1.0f`)
     fn transform_expr_float_constant(&mut self, _typ: &Type, value: &f32) -> Expr {
         Expr::float_constant(*value)

cprover_bindings/src/goto_program/typ.rs

@@ -418,6 +418,11 @@ impl Type {
         }
     }
 
+    pub fn is_bitfield(&self) -> bool {
+        let concrete = self.unwrap_typedef();
+        matches!(concrete, CBitField { .. })
+    }
+
     pub fn is_bool(&self) -> bool {
         let concrete = self.unwrap_typedef();
         match concrete {
@@ -1211,7 +1216,7 @@ impl Type {
     }
 
     pub fn one(&self) -> Expr {
-        if self.is_integer() {
+        if self.is_integer() || self.is_bitfield() {
             Expr::int_constant(1, self.clone())
         } else if self.is_c_bool() {
             Expr::c_true()
@@ -1225,8 +1230,10 @@ impl Type {
     }
 
     pub fn zero(&self) -> Expr {
-        if self.is_integer() {
+        if self.is_integer() || self.is_bitfield() {
             Expr::int_constant(0, self.clone())
+        } else if self.is_bool() {
+            Expr::bool_false()
         } else if self.is_c_bool() {
             Expr::c_false()
         } else if self.is_float() {
@@ -1236,7 +1243,63 @@ impl Type {
         } else if self.is_pointer() {
             Expr::pointer_constant(0, self.clone())
         } else {
-            unreachable!("Can't convert {:?} to a one value", self);
+            unreachable!("Can't convert {:?} to a zero value", self);
+        }
+    }
+
+    pub fn zero_initializer(&self, st: &SymbolTable) -> Expr {
+        let concrete = self.unwrap_typedef();
+        match concrete {
+            // Base case
+            Bool
+            | CBitField { .. }
+            | CInteger(_)
+            | Double
+            | Float
+            | Pointer { .. }
+            | Signedbv { .. }
+            | Unsignedbv { .. } => self.zero(),
+
+            // Recursive cases
+            Array { typ, size } => typ.zero_initializer(st).array_constant(*size),
+            InfiniteArray { typ } => typ.zero_initializer(st).infinite_array_constant(),
+            Struct { components, .. } => {
+                let values: Vec<Expr> =
+                    components.iter().map(|c| c.typ().zero_initializer(st)).collect();
+                Expr::struct_expr_from_padded_values(self.clone(), values, st)
+            }
+            StructTag(tag) => st.lookup(*tag).unwrap().typ.zero_initializer(st),
+            TypeDef { .. } => unreachable!("Should have been normalized away"),
+            Union { components, .. } => {
+                if components.is_empty() {
+                    Expr::empty_union(self.clone(), st)
+                } else {
+                    let largest = components.iter().max_by_key(|c| c.sizeof_in_bits(st)).unwrap();
+                    Expr::union_expr(
+                        self.clone(),
+                        largest.name(),
+                        largest.typ().zero_initializer(st),
+                        st,
+                    )
+                }
+            }
+            UnionTag(tag) => st.lookup(*tag).unwrap().typ.zero_initializer(st),
+            Vector { typ, size } => {
+                let zero = typ.zero_initializer(st);
+                let size = (*size).try_into().unwrap();
+                let elems = vec![zero; size];
+                Expr::vector_expr(self.clone(), elems)
+            }
+
+            // Cases that can't be zero init
+            // Note that other than flexible array, none of these can be fields in a struct or union
+            Code { .. }
+            | Constructor
+            | Empty
+            | FlexibleArray { .. }
+            | IncompleteStruct { .. }
+            | IncompleteUnion { .. }
+            | VariadicCode { .. } => panic!("Can't zero init {:?}", self),
         }
     }
 }

cprover_bindings/src/irep/irep_id.rs

@@ -582,6 +582,7 @@ pub enum IrepId {
     Popcount,
     CountLeadingZeros,
     CountTrailingZeros,
+    EmptyUnion,
     FunctionType,
     Noreturn,
     CNoreturn,
@@ -1444,6 +1445,7 @@ impl ToString for IrepId {
             IrepId::Popcount => "popcount",
             IrepId::CountLeadingZeros => "count_leading_zeros",
             IrepId::CountTrailingZeros => "count_trailing_zeros",
+            IrepId::EmptyUnion => "empty_union",
             IrepId::FunctionType => "function_type",
             IrepId::Noreturn => "noreturn",
             IrepId::CNoreturn => "#noreturn",

cprover_bindings/src/irep/to_irep.rs

@@ -219,6 +219,7 @@ impl ToIrep for ExprValue {
                     )],
                 }
             }
+            ExprValue::EmptyUnion => Irep::just_id(IrepId::EmptyUnion),
             ExprValue::FloatConstant(i) => {
                 let c: u32 = i.to_bits();
                 Irep {