cranelift-codegen 0.134.0

Low-level code generator library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Analysis for rewriting branch-to-unconditional-trap into conditional trap
//! instructions.
//!
//! Given this instruction:
//!
//! ```clif
//! brif v0, block1, block2
//! ```
//!
//! If we know that `block1` does nothing but immediately trap then we can
//! rewrite that `brif` into the following:
//!
//! ```clif
//! trapnz v0, <trapcode>
//! jump block2
//! ```
//!
//! (And we can do the equivalent with `trapz` if `block2` immediately traps).
//!
//! This transformation allows for the conditional trap instructions to be GVN'd
//! and for our egraphs mid-end to generally better optimize the program. We
//! additionally have better codegen in our backends for `trapz`/`trapnz` than
//! branches to unconditional traps.
//!
//! This module only provides the *analysis* of which blocks are "just trap"
//! blocks; the actual rewrite is performed by `simplify_skeleton` ISLE rules in
//! the egraph pass, which consult this analysis via the `just_trap_block` ISLE
//! constructor.

use crate::FxHashMap;
use crate::inst_predicates::is_pure_for_egraph;
use crate::ir::{self, InstructionData, Opcode};
use cranelift_entity::EntitySet;

/// On-demand, memoized analysis of which blocks are "just trap" blocks.
///
/// A block is a "just trap" block when its terminator is an unconditional
/// `trap` and all of its other instructions in the block are pure.
///
/// Results are memoized so that it does not matter in which order blocks are
/// analyzed or instructions are processed; callers can ask for the analysis
/// result of any block at any time.
#[derive(Default)]
pub struct BranchToTrapAnalysis {
    /// The set of blocks we have already analyzed.
    analyzed_blocks: EntitySet<ir::Block>,

    /// Given that we have already analyzed a block and found it to be a
    /// just-trap block, what is its trap code?
    just_trap_block_codes: FxHashMap<ir::Block, ir::TrapCode>,
}

impl BranchToTrapAnalysis {
    /// Determine whether `block` is a "just trap" block and, if so, return the
    /// trap code of its terminating `trap` instruction.
    pub fn analyze_block(&mut self, func: &ir::Function, block: ir::Block) -> Option<ir::TrapCode> {
        if self.analyzed_blocks.insert(block) {
            let code = Self::analyze_block_impl(func, block);
            if let Some(code) = code {
                let old_entry = self.just_trap_block_codes.insert(block, code);
                debug_assert!(old_entry.is_none());
            }
            code
        } else {
            self.just_trap_block_codes.get(&block).copied()
        }
    }

    fn analyze_block_impl(func: &ir::Function, block: ir::Block) -> Option<ir::TrapCode> {
        let last = func.layout.last_inst(block)?;
        let code = match func.dfg.insts[last] {
            InstructionData::Trap {
                opcode: Opcode::Trap,
                code,
            } => code,
            _ => return None,
        };

        for inst in func.layout.block_insts(block) {
            if inst != last && !is_pure_for_egraph(func, inst) {
                return None;
            }
        }

        Some(code)
    }
}