regalloc2/ion/
dump.rs

1//! Debugging output.
2
3use super::Env;
4use crate::{Block, Function, ProgPoint};
5
6impl<'a, F: Function> Env<'a, F> {
7    pub fn dump_state(&self) {
8        trace!("Bundles:");
9        for (i, b) in self.bundles.iter().enumerate() {
10            trace!(
11                "bundle{}: spillset={:?} alloc={:?}",
12                i,
13                b.spillset,
14                b.allocation
15            );
16            for entry in &b.ranges {
17                trace!(
18                    " * range {:?} -- {:?}: range{}",
19                    entry.range.from,
20                    entry.range.to,
21                    entry.index.index()
22                );
23            }
24        }
25        trace!("VRegs:");
26        for (i, v) in self.vregs.iter().enumerate() {
27            trace!("vreg{}:", i);
28            for entry in &v.ranges {
29                trace!(
30                    " * range {:?} -- {:?}: range{}",
31                    entry.range.from,
32                    entry.range.to,
33                    entry.index.index()
34                );
35            }
36        }
37        trace!("Ranges:");
38        for (i, r) in self.ranges.iter().enumerate() {
39            trace!(
40                "range{}: range={:?} vreg={:?} bundle={:?} weight={:?}",
41                i,
42                r.range,
43                r.vreg,
44                r.bundle,
45                r.uses_spill_weight(),
46            );
47            for u in &r.uses {
48                trace!(" * use at {:?} (slot {}): {:?}", u.pos, u.slot, u.operand);
49            }
50        }
51    }
52
53    pub fn annotate(&mut self, progpoint: ProgPoint, s: String) {
54        if self.annotations_enabled {
55            self.debug_annotations
56                .entry(progpoint)
57                .or_insert_with(|| vec![])
58                .push(s);
59        }
60    }
61
62    pub fn dump_results(&self) {
63        log::info!("=== REGALLOC RESULTS ===");
64        for block in 0..self.func.num_blocks() {
65            let block = Block::new(block);
66            log::info!(
67                "block{}: [succs {:?} preds {:?}]",
68                block.index(),
69                self.func
70                    .block_succs(block)
71                    .iter()
72                    .map(|b| b.index())
73                    .collect::<Vec<_>>(),
74                self.func
75                    .block_preds(block)
76                    .iter()
77                    .map(|b| b.index())
78                    .collect::<Vec<_>>()
79            );
80            for inst in self.func.block_insns(block).iter() {
81                for annotation in self
82                    .debug_annotations
83                    .get(&ProgPoint::before(inst))
84                    .map(|v| &v[..])
85                    .unwrap_or(&[])
86                {
87                    log::info!("  inst{}-pre: {}", inst.index(), annotation);
88                }
89                let ops = self
90                    .func
91                    .inst_operands(inst)
92                    .iter()
93                    .map(|op| format!("{}", op))
94                    .collect::<Vec<_>>();
95                let clobbers = self
96                    .func
97                    .inst_clobbers(inst)
98                    .into_iter()
99                    .map(|preg| format!("{}", preg))
100                    .collect::<Vec<_>>();
101                let allocs = (0..ops.len())
102                    .map(|i| format!("{}", self.get_alloc(inst, i)))
103                    .collect::<Vec<_>>();
104                let opname = if self.func.is_branch(inst) {
105                    "br"
106                } else if self.func.is_ret(inst) {
107                    "ret"
108                } else {
109                    "op"
110                };
111                let args = ops
112                    .iter()
113                    .zip(allocs.iter())
114                    .map(|(op, alloc)| format!("{} [{}]", op, alloc))
115                    .collect::<Vec<_>>();
116                let clobbers = if clobbers.is_empty() {
117                    "".to_string()
118                } else {
119                    format!(" [clobber: {}]", clobbers.join(", "))
120                };
121                log::info!(
122                    "  inst{}: {} {}{}",
123                    inst.index(),
124                    opname,
125                    args.join(", "),
126                    clobbers
127                );
128                for annotation in self
129                    .debug_annotations
130                    .get(&ProgPoint::after(inst))
131                    .map(|v| &v[..])
132                    .unwrap_or(&[])
133                {
134                    log::info!("  inst{}-post: {}", inst.index(), annotation);
135                }
136            }
137        }
138    }
139}
regalloc2/ion/dump.rs

regalloc2/ion/
dump.rs
