ee5982fd16
This lets us avoid the cost of `cranelift_codegen::ir::Opcode` to `peepmatic_runtime::Operator` conversion overhead, and paves the way for allowing Peepmatic to support non-clif optimizations (e.g. vcode optimizations). Rather than defining our own `peepmatic::Operator` type like we used to, now the whole `peepmatic` crate is effectively generic over a `TOperator` type parameter. For the Cranelift integration, we use `cranelift_codegen::ir::Opcode` as the concrete type for our `TOperator` type parameter. For testing, we also define a `TestOperator` type, so that we can test Peepmatic code without building all of Cranelift, and we can keep them somewhat isolated from each other. The methods that `peepmatic::Operator` had are now translated into trait bounds on the `TOperator` type. These traits need to be shared between all of `peepmatic`, `peepmatic-runtime`, and `cranelift-codegen`'s Peepmatic integration. Therefore, these new traits live in a new crate: `peepmatic-traits`. This crate acts as a header file of sorts for shared trait/type/macro definitions. Additionally, the `peepmatic-runtime` crate no longer depends on the `peepmatic-macro` procedural macro crate, which should lead to faster build times for Cranelift when it is using pre-built peephole optimizers.
97 lines
3.2 KiB
Rust
97 lines
3.2 KiB
Rust
//! Compiled peephole optimizations.
|
|
|
|
use crate::error::Result;
|
|
use crate::instruction_set::InstructionSet;
|
|
use crate::integer_interner::IntegerInterner;
|
|
use crate::linear::{Action, MatchOp, MatchResult};
|
|
use crate::optimizer::PeepholeOptimizer;
|
|
use crate::paths::PathInterner;
|
|
use peepmatic_automata::Automaton;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::fmt::Debug;
|
|
use std::hash::Hash;
|
|
|
|
#[cfg(feature = "construct")]
|
|
use std::fs;
|
|
#[cfg(feature = "construct")]
|
|
use std::path::Path;
|
|
|
|
/// A compiled set of peephole optimizations.
|
|
///
|
|
/// This is the compilation result of the `peepmatic` crate, after its taken a
|
|
/// bunch of optimizations written in the DSL and lowered and combined them.
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct PeepholeOptimizations<TOperator>
|
|
where
|
|
TOperator: 'static + Copy + Debug + Eq + Hash,
|
|
{
|
|
/// The instruction paths referenced by the peephole optimizations.
|
|
pub paths: PathInterner,
|
|
|
|
/// Not all integers we're matching on fit in the `u32` that we use as the
|
|
/// result of match operations. So we intern them and refer to them by id.
|
|
pub integers: IntegerInterner,
|
|
|
|
/// The underlying automata for matching optimizations' left-hand sides, and
|
|
/// building up the corresponding right-hand side.
|
|
pub automata: Automaton<MatchResult, MatchOp, Box<[Action<TOperator>]>>,
|
|
}
|
|
|
|
impl<TOperator> PeepholeOptimizations<TOperator>
|
|
where
|
|
TOperator: 'static + Copy + Debug + Eq + Hash,
|
|
{
|
|
/// Deserialize a `PeepholeOptimizations` from bytes.
|
|
pub fn deserialize<'a>(serialized: &'a [u8]) -> Result<Self>
|
|
where
|
|
TOperator: serde::Deserialize<'a>,
|
|
{
|
|
let peep_opt: Self = bincode::deserialize(serialized)?;
|
|
Ok(peep_opt)
|
|
}
|
|
|
|
/// Serialize these peephole optimizations out to the file at the given path.
|
|
///
|
|
/// Requires that the `"construct"` cargo feature is enabled.
|
|
#[cfg(feature = "construct")]
|
|
pub fn serialize_to_file(&self, path: &Path) -> Result<()>
|
|
where
|
|
TOperator: serde::Serialize,
|
|
{
|
|
let file = fs::File::create(path)?;
|
|
bincode::serialize_into(file, self)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<TOperator> PeepholeOptimizations<TOperator>
|
|
where
|
|
TOperator: 'static + Copy + Debug + Eq + Hash,
|
|
{
|
|
/// Create a new peephole optimizer instance from this set of peephole
|
|
/// optimizations.
|
|
///
|
|
/// The peephole optimizer instance can be used to apply these peephole
|
|
/// optimizations. When checking multiple instructions for whether they can
|
|
/// be optimized, it is more performant to reuse a single peephole optimizer
|
|
/// instance, rather than create a new one for each instruction. Reusing the
|
|
/// peephole optimizer instance allows the reuse of a few internal
|
|
/// allocations.
|
|
pub fn optimizer<'peep, 'ctx, TInstructionSet>(
|
|
&'peep self,
|
|
instr_set: TInstructionSet,
|
|
) -> PeepholeOptimizer<'peep, 'ctx, TInstructionSet>
|
|
where
|
|
TInstructionSet: InstructionSet<'ctx, Operator = TOperator>,
|
|
TOperator: Into<std::num::NonZeroU32>,
|
|
{
|
|
PeepholeOptimizer {
|
|
peep_opt: self,
|
|
instr_set,
|
|
right_hand_sides: vec![],
|
|
actions: vec![],
|
|
backtracking_states: vec![],
|
|
}
|
|
}
|
|
}
|