Add serde serialization support for the full clif ir

cranelift/codegen/src/ir/constant.rs

@@ -19,12 +19,16 @@ use core::slice::Iter;
 use core::str::{from_utf8, FromStr};
 use cranelift_entity::EntityRef;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// This type describes the actual constant data. Note that the bytes stored in this structure are
 /// expected to be in little-endian order; this is due to ease-of-use when interacting with
 /// WebAssembly values, which are [little-endian by design].
 ///
 /// [little-endian by design]: https://github.com/WebAssembly/design/blob/master/Portability.md
 #[derive(Clone, Hash, Eq, PartialEq, Debug, Default)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct ConstantData(Vec<u8>);
 
 impl FromIterator<u8> for ConstantData {
@@ -173,6 +177,7 @@ pub type ConstantOffset = u32;
 /// from the beginning of the function is known (see
 /// `relaxation` in `relaxation.rs`).
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct ConstantPoolEntry {
     data: ConstantData,
     offset: Option<ConstantOffset>,
@@ -197,6 +202,7 @@ impl ConstantPoolEntry {
 /// Maintains the mapping between a constant handle (i.e.  [`Constant`](crate::ir::Constant)) and
 /// its constant data (i.e.  [`ConstantData`](crate::ir::ConstantData)).
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct ConstantPool {
     /// This mapping maintains the insertion order as long as Constants are created with
     /// sequentially increasing integers.

cranelift/codegen/src/ir/dfg.rs

@@ -21,6 +21,9 @@ use core::mem;
 use core::ops::{Index, IndexMut};
 use core::u16;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// A data flow graph defines all instructions and basic blocks in a function as well as
 /// the data flow dependencies between them. The DFG also tracks values which can be either
 /// instruction results or block parameters.
@@ -29,6 +32,7 @@ use core::u16;
 /// `Layout` data structure which forms the other half of the function representation.
 ///
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct DataFlowGraph {
     /// Data about all of the instructions in the function, including opcodes and operands.
     /// The instructions in this map are not in program order. That is tracked by `Layout`, along
@@ -416,6 +420,7 @@ impl ValueDef {
 
 /// Internal table storage for extended values.
 #[derive(Clone, Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 enum ValueData {
     /// Value is defined by an instruction.
     Inst { ty: Type, num: u16, inst: Inst },
@@ -935,6 +940,7 @@ impl DataFlowGraph {
 /// branches to this block must provide matching arguments, and the arguments to the entry block must
 /// match the function arguments.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 struct BlockData {
     /// List of parameters to this block.
     params: ValueList,

cranelift/codegen/src/ir/entities.rs

@@ -33,6 +33,7 @@ use serde::{Deserialize, Serialize};
 ///
 /// While the order is stable, it is arbitrary and does not necessarily resemble the layout order.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Block(u32);
 entity_impl!(Block, "block");
 
@@ -65,6 +66,7 @@ impl Block {
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Value(u32);
 entity_impl!(Value, "v");
 
@@ -97,6 +99,7 @@ impl Value {
 ///
 /// While the order is stable, it is arbitrary and does not necessarily resemble the layout order.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Inst(u32);
 entity_impl!(Inst, "inst");
 
@@ -152,6 +155,7 @@ impl StackSlot {
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct GlobalValue(u32);
 entity_impl!(GlobalValue, "gv");
 
@@ -177,6 +181,7 @@ impl GlobalValue {
 /// While the order is stable, it is arbitrary and does not necessarily resemble the order in which
 /// the constants are written in the constant pool.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Constant(u32);
 entity_impl!(Constant, "const");
 
@@ -202,6 +207,7 @@ impl Constant {
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Immediate(u32);
 entity_impl!(Immediate, "imm");
 
@@ -267,6 +273,7 @@ impl JumpTable {
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct FuncRef(u32);
 entity_impl!(FuncRef, "fn");
 
@@ -298,6 +305,7 @@ impl FuncRef {
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct SigRef(u32);
 entity_impl!(SigRef, "sig");
 
@@ -323,6 +331,7 @@ impl SigRef {
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Heap(u32);
 entity_impl!(Heap, "heap");
 
@@ -349,6 +358,7 @@ impl Heap {
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Table(u32);
 entity_impl!(Table, "table");
 
@@ -367,6 +377,7 @@ impl Table {
 
 /// An opaque reference to any of the entities defined in this module that can appear in CLIF IR.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum AnyEntity {
     /// The whole function.
     Function,

cranelift/codegen/src/ir/extfunc.rs

@@ -409,6 +409,7 @@ impl FromStr for ArgumentPurpose {
 ///
 /// Information about a function that can be called directly with a direct `call` instruction.
 #[derive(Clone, Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct ExtFuncData {
     /// Name of the external function.
     pub name: ExternalName,

cranelift/codegen/src/ir/extname.rs

@@ -9,6 +9,9 @@ use core::cmp;
 use core::fmt::{self, Write};
 use core::str::FromStr;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 const TESTCASE_NAME_LENGTH: usize = 16;
 
 /// The name of an external is either a reference to a user-defined symbol
@@ -23,6 +26,7 @@ const TESTCASE_NAME_LENGTH: usize = 16;
 /// In particular, many `.clif` test files use function names to identify
 /// functions.
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum ExternalName {
     /// A name in a user-defined symbol table. Cranelift does not interpret
     /// these numbers in any way.

cranelift/codegen/src/ir/function.rs

@@ -21,11 +21,15 @@ use crate::write::write_function;
 use alloc::vec::Vec;
 use core::fmt;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// A function.
 ///
 /// Functions can be cloned, but it is not a very fast operation.
 /// The clone will have all the same entity numbers as the original.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Function {
     /// Name of this function. Mostly used by `.clif` files.
     pub name: ExternalName,

cranelift/codegen/src/ir/globalvalue.rs

@@ -6,8 +6,12 @@ use crate::isa::TargetIsa;
 use crate::machinst::RelocDistance;
 use core::fmt;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// Information about a global value declaration.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum GlobalValueData {
     /// Value is the address of the VM context struct.
     VMContext,

cranelift/codegen/src/ir/heap.rs

@@ -4,8 +4,12 @@ use crate::ir::immediates::Uimm64;
 use crate::ir::{GlobalValue, Type};
 use core::fmt;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// Information about a heap declaration.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct HeapData {
     /// The address of the start of the heap's storage.
     pub base: GlobalValue,
@@ -26,6 +30,7 @@ pub struct HeapData {
 
 /// Style of heap including style-specific information.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum HeapStyle {
     /// A dynamic heap can be relocated to a different base address when it is grown.
     Dynamic {

cranelift/codegen/src/ir/immediates.rs

@@ -48,6 +48,7 @@ impl IntoBytes for Vec<u8> {
 /// An `Imm64` operand can also be used to represent immediate values of smaller integer types by
 /// sign-extending to `i64`.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Imm64(i64);
 
 impl Imm64 {
@@ -148,6 +149,7 @@ impl FromStr for Imm64 {
 /// A `Uimm64` operand can also be used to represent immediate values of smaller integer types by
 /// zero-extending to `i64`.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Uimm64(u64);
 
 impl Uimm64 {
@@ -279,6 +281,7 @@ pub type Uimm8 = u8;
 ///
 /// This is used to represent sizes of memory objects.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Uimm32(u32);
 
 impl Into<u32> for Uimm32 {
@@ -362,6 +365,7 @@ impl From<&[u8]> for V128Imm {
 /// This is used to encode an immediate offset for load/store instructions. All supported ISAs have
 /// a maximum load/store offset that fits in an `i32`.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Offset32(i32);
 
 impl Offset32 {
@@ -451,6 +455,7 @@ impl FromStr for Offset32 {
 ///
 /// All bit patterns are allowed.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct Ieee32(u32);
 
@@ -459,6 +464,7 @@ pub struct Ieee32(u32);
 ///
 /// All bit patterns are allowed.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 #[repr(C)]
 pub struct Ieee64(u64);
 

cranelift/codegen/src/ir/instructions.rs

@@ -13,6 +13,9 @@ use core::num::NonZeroU32;
 use core::ops::{Deref, DerefMut};
 use core::str::FromStr;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 use crate::ir::{self, trapcode::TrapCode, types, Block, FuncRef, JumpTable, SigRef, Type, Value};
 use crate::isa;
 

cranelift/codegen/src/ir/jumptable.rs

@@ -8,10 +8,14 @@ use alloc::vec::Vec;
 use core::fmt::{self, Display, Formatter};
 use core::slice::{Iter, IterMut};
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// Contents of a jump table.
 ///
 /// All jump tables use 0-based indexing and are densely populated.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct JumpTableData {
     // Table entries.
     table: Vec<Block>,

cranelift/codegen/src/ir/layout.rs

@@ -781,6 +781,86 @@ impl<'f> DoubleEndedIterator for Insts<'f> {
     }
 }
 
+#[cfg(feature = "enable-serde")]
+mod serde {
+    use ::serde::de::{Deserializer, Error, SeqAccess, Visitor};
+    use ::serde::ser::{SerializeSeq, Serializer};
+    use ::serde::{Deserialize, Serialize};
+    use core::convert::TryFrom;
+    use core::fmt;
+    use core::marker::PhantomData;
+
+    use super::*;
+
+    impl Serialize for Layout {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            let size = self.blocks().count() * 2
+                + self
+                    .blocks()
+                    .map(|block| self.block_insts(block).count())
+                    .sum::<usize>();
+            let mut seq = serializer.serialize_seq(Some(size))?;
+            for block in self.blocks() {
+                seq.serialize_element(&block)?;
+                seq.serialize_element(&u32::try_from(self.block_insts(block).count()).unwrap())?;
+                for inst in self.block_insts(block) {
+                    seq.serialize_element(&inst)?;
+                }
+            }
+            seq.end()
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Layout {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_seq(LayoutVisitor {
+                marker: PhantomData,
+            })
+        }
+    }
+
+    struct LayoutVisitor {
+        marker: PhantomData<fn() -> Layout>,
+    }
+
+    impl<'de> Visitor<'de> for LayoutVisitor {
+        type Value = Layout;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            write!(formatter, "a `cranelift_codegen::ir::Layout`")
+        }
+
+        fn visit_seq<M>(self, mut access: M) -> Result<Self::Value, M::Error>
+        where
+            M: SeqAccess<'de>,
+        {
+            let mut layout = Layout::new();
+
+            while let Some(block) = access.next_element::<Block>()? {
+                layout.append_block(block);
+
+                let count = access
+                    .next_element::<u32>()?
+                    .ok_or_else(|| Error::missing_field("count"))?;
+                for _ in 0..count {
+                    let inst = access
+                        .next_element::<Inst>()?
+                        .ok_or_else(|| Error::missing_field("inst"))?;
+                    layout.append_inst(inst, block);
+                }
+            }
+
+            Ok(layout)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::Layout;

cranelift/codegen/src/ir/memflags.rs

@@ -2,6 +2,9 @@
 
 use core::fmt;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 enum FlagBit {
     Notrap,
     Aligned,
@@ -32,6 +35,7 @@ pub enum Endianness {
 /// be overridden for individual accesses by explicitly specifying little- or big-endian
 /// semantics via the flags.
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct MemFlags {
     bits: u8,
 }

cranelift/codegen/src/ir/mod.rs

@@ -91,6 +91,7 @@ entity_impl!(ValueLabel, "val");
 
 /// A label of a Value.
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct ValueLabelStart {
     /// Source location when it is in effect
     pub from: SourceLoc,
@@ -101,6 +102,7 @@ pub struct ValueLabelStart {
 
 /// Value label assignements: label starts or value aliases.
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum ValueLabelAssignments {
     /// Original value labels assigned at transform.
     Starts(alloc::vec::Vec<ValueLabelStart>),

cranelift/codegen/src/ir/table.rs

@@ -4,8 +4,12 @@ use crate::ir::immediates::Uimm64;
 use crate::ir::{GlobalValue, Type};
 use core::fmt;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// Information about a table declaration.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct TableData {
     /// Global value giving the address of the start of the table.
     pub base_gv: GlobalValue,

cranelift/codegen/src/isa/encoding.rs

@@ -6,6 +6,9 @@ use crate::isa::constraints::{BranchRange, RecipeConstraints};
 use crate::regalloc::RegDiversions;
 use core::fmt;
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// Bits needed to encode an instruction as binary machine code.
 ///
 /// The encoding consists of two parts, both specific to the target ISA: An encoding *recipe*, and
@@ -13,6 +16,7 @@ use core::fmt;
 /// operands to encoded bits. The encoding bits provide additional information to the recipe,
 /// typically parts of the opcode.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Encoding {
     recipe: u16,
     bits: u16,

cranelift/codegen/src/regalloc/diversion.rs

@@ -15,6 +15,9 @@ use crate::isa::{RegInfo, RegUnit};
 use core::fmt;
 use cranelift_entity::{SparseMap, SparseMapValue};
 
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
 /// A diversion of a value from its original location to a new register or stack location.
 ///
 /// In IR, a diversion is represented by a `regmove` instruction, possibly a chain of them for the
@@ -23,6 +26,7 @@ use cranelift_entity::{SparseMap, SparseMapValue};
 /// When tracking diversions, the `from` field is the original assigned value location, and `to` is
 /// the current one.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct Diversion {
     /// The original value location.
     pub from: ValueLoc,
@@ -40,18 +44,21 @@ impl Diversion {
 
 /// Keep track of diversions in a block.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct RegDiversions {
     current: FxHashMap<Value, Diversion>,
 }
 
 /// Keep track of diversions at the entry of block.
 #[derive(Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 struct EntryRegDiversionsValue {
     key: Block,
     divert: RegDiversions,
 }
 
 /// Map block to their matching RegDiversions at basic blocks entry.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct EntryRegDiversions {
     map: SparseMap<Block, EntryRegDiversionsValue>,
 }