egraph-based midend: draw the rest of the owl (productionized). (#4953)

* egraph-based midend: draw the rest of the owl. * Rename `egg` submodule of cranelift-codegen to `egraph`. * Apply some feedback from @jsharp during code walkthrough. * Remove recursion from find_best_node by doing a single pass. Rather than recursively computing the lowest-cost node for a given eclass and memoizing the answer at each eclass node, we can do a single forward pass; because every eclass node refers only to earlier nodes, this is sufficient. The behavior may slightly differ from the earlier behavior because we cannot short-circuit costs to zero once a node is elaborated; but in practice this should not matter. * Make elaboration non-recursive. Use an explicit stack instead (with `ElabStackEntry` entries, alongside a result stack). * Make elaboration traversal of the domtree non-recursive/stack-safe. * Work analysis logic in Cranelift-side egraph glue into a general analysis framework in cranelift-egraph. * Apply static recursion limit to rule application. * Fix aarch64 wrt dynamic-vector support -- broken rebase. * Topo-sort cranelift-egraph before cranelift-codegen in publish script, like the comment instructs me to! * Fix multi-result call testcase. * Include `cranelift-egraph` in `PUBLISHED_CRATES`. * Fix atomic_rmw: not really a load. * Remove now-unnecessary PartialOrd/Ord derivations. * Address some code-review comments. * Review feedback. * Review feedback. * No overlap in mid-end rules, because we are defining a multi-constructor. * rustfmt * Review feedback. * Review feedback. * Review feedback. * Review feedback. * Remove redundant `mut`. * Add comment noting what rules can do. * Review feedback. * Clarify comment wording. * Update `has_memory_fence_semantics`. * Apply @jameysharp's improved loop-level computation. Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fix suggestion commit. * Fix off-by-one in new loop-nest analysis. * Review feedback. * Review feedback. * Review feedback. * Use `Default`, not `std::default::Default`, as per @fitzgen Co-authored-by: Nick Fitzgerald <fitzgen@gmail.com> * Apply @fitzgen's comment elaboration to a doc-comment. Co-authored-by: Nick Fitzgerald <fitzgen@gmail.com> * Add stat for hitting the rewrite-depth limit. * Some code motion in split prelude to make the diff a little clearer wrt `main`. * Take @jameysharp's suggested `try_into()` usage for blockparam indices. Co-authored-by: Jamey Sharp <jamey@minilop.net> * Take @jameysharp's suggestion to avoid double-match on load op. Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fix suggestion (add import). * Review feedback. * Fix stack_load handling. * Remove redundant can_store case. * Take @jameysharp's suggested improvement to FuncEGraph::build() logic Co-authored-by: Jamey Sharp <jamey@minilop.net> * Tweaks to FuncEGraph::build() on top of suggestion. * Take @jameysharp's suggested clarified condition Co-authored-by: Jamey Sharp <jamey@minilop.net> * Clean up after suggestion (unused variable). * Fix loop analysis. * loop level asserts * Revert constant-space loop analysis -- edge cases were incorrect, so let's go with the simple thing for now. * Take @jameysharp's suggestion re: result_tys Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fix up after suggestion * Take @jameysharp's suggestion to use fold rather than reduce Co-authored-by: Jamey Sharp <jamey@minilop.net> * Fixup after suggestion * Take @jameysharp's suggestion to remove elaborate_eclass_use's return value. * Clarifying comment in terminator insts. Co-authored-by: Jamey Sharp <jamey@minilop.net> Co-authored-by: Nick Fitzgerald <fitzgen@gmail.com>
2022-10-11 18:15:53 -07:00
parent e2f1ced0b6
commit 2be12a5167
59 changed files with 5125 additions and 1580 deletions
--- a/cranelift/codegen/src/egraph/domtree.rs
+++ b/cranelift/codegen/src/egraph/domtree.rs
@@ -0,0 +1,69 @@
+//! Extended domtree with various traversal support.
+
+use crate::dominator_tree::DominatorTree;
+use crate::ir::{Block, Function};
+use cranelift_entity::{packed_option::PackedOption, SecondaryMap};
+
+#[derive(Clone, Debug)]
+pub(crate) struct DomTreeWithChildren {
+    nodes: SecondaryMap<Block, DomTreeNode>,
+    root: Block,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct DomTreeNode {
+    children: PackedOption<Block>,
+    next: PackedOption<Block>,
+}
+
+impl DomTreeWithChildren {
+    pub(crate) fn new(func: &Function, domtree: &DominatorTree) -> DomTreeWithChildren {
+        let mut nodes: SecondaryMap<Block, DomTreeNode> =
+            SecondaryMap::with_capacity(func.dfg.num_blocks());
+
+        for block in func.layout.blocks() {
+            let idom_inst = match domtree.idom(block) {
+                Some(idom_inst) => idom_inst,
+                None => continue,
+            };
+            let idom = func
+                .layout
+                .inst_block(idom_inst)
+                .expect("Dominating instruction should be part of a block");
+
+            nodes[block].next = nodes[idom].children;
+            nodes[idom].children = block.into();
+        }
+
+        let root = func.layout.entry_block().unwrap();
+
+        Self { nodes, root }
+    }
+
+    pub(crate) fn root(&self) -> Block {
+        self.root
+    }
+
+    pub(crate) fn children<'a>(&'a self, block: Block) -> DomTreeChildIter<'a> {
+        let block = self.nodes[block].children;
+        DomTreeChildIter {
+            domtree: self,
+            block,
+        }
+    }
+}
+
+pub(crate) struct DomTreeChildIter<'a> {
+    domtree: &'a DomTreeWithChildren,
+    block: PackedOption<Block>,
+}
+
+impl<'a> Iterator for DomTreeChildIter<'a> {
+    type Item = Block;
+    fn next(&mut self) -> Option<Block> {
+        self.block.expand().map(|block| {
+            self.block = self.domtree.nodes[block].next;
+            block
+        })
+    }
+}