Introduce CfgTraits abstraction

The CfgTraits abstraction simplfies writing algorithms that are
generic over the type of CFG, and enables writing such algorithms
as regular non-template code that operates on opaque references
to CFG blocks and values.

Implementations of CfgTraits provide operations on the concrete
CFG types, e.g. `IrCfgTraits::BlockRef` is `BasicBlock *`.

CfgInterface is an abstract base class which provides operations
on opaque types CfgBlockRef and CfgValueRef. Those opaque types
encapsulate a `void *`, but the meaning depends on the concrete
CFG type. For example, MachineCfgTraits -- for use with MachineIR
in SSA form -- encodes a Register inside CfgValueRef. Converting
between concrete references and opaque/generic ones is done by
CfgTraits::{fromGeneric,toGeneric}. Convenience methods
CfgTraits::{un}wrap{Iterator,Range} are available as well.

Writing algorithms in terms of CfgInterface adds some overhead
(virtual method calls, plus in same cases it removes the
opportunity to inline iterators), but can be much more convenient
since generic algorithms can be written as non-templates.

This patch adds implementations of CfgTraits for all CFGs on
which dominator trees are calculated, so that the dominator
tree can be ported to this machinery. Only IrCfgTraits (LLVM IR)
and MachineCfgTraits (Machine IR in SSA form) are complete, the
other implementations are limited to the absolute minimum
required to make the upcoming dominator tree changes work.

v5:
- fix MachineCfgTraits::blockdef_iterator and allow it to iterate over
  the instructions in a bundle
- use MachineBasicBlock::printName

v6:
- implement predecessors/successors for all CfgTraits implementations
- fix error in unwrapRange
- rename toGeneric/fromGeneric into wrapRef/unwrapRef to have naming
  that is consistent with {wrap,unwrap}{Iterator,Range}
- use getVRegDef instead of getUniqueVRegDef

v7:
- std::forward fix in wrapping_iterator
- fix typos

v8:
- cleanup operators on CfgOpaqueType
- address other review comments

Change-Id: Ia75f4f268fded33fca11218a7d578c9aec1f3f4d

Differential Revision: https://reviews.llvm.org/D83088

Author: nhaehnle

clang/include/clang/Analysis/Analyses/Dominators.h

@@ -18,11 +18,100 @@
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/iterator.h"
-#include "llvm/Support/GenericIteratedDominanceFrontier.h"
+#include "llvm/Support/CfgTraits.h"
 #include "llvm/Support/GenericDomTree.h"
 #include "llvm/Support/GenericDomTreeConstruction.h"
+#include "llvm/Support/GenericIteratedDominanceFrontier.h"
 #include "llvm/Support/raw_ostream.h"
 
+namespace clang {
+
+/// Partial CFG traits for MLIR's CFG, without a value type.
+class CfgTraitsBase : public llvm::CfgTraitsBase {
+public:
+  using ParentType = CFG;
+  using BlockRef = CFGBlock *;
+  using ValueRef = void;
+
+  static llvm::CfgBlockRef wrapRef(BlockRef block) {
+    return makeOpaque<llvm::CfgBlockRefTag>(block);
+  }
+  static BlockRef unwrapRef(llvm::CfgBlockRef block) {
+    return static_cast<BlockRef>(getOpaque(block));
+  }
+};
+
+class CfgTraits : public llvm::CfgTraits<CfgTraitsBase, CfgTraits> {
+public:
+  static ParentType *getBlockParent(CFGBlock *block) {
+    return block->getParent();
+  }
+
+  // Clang's CFG contains null pointers for unreachable successors, e.g. when an
+  // if statement's condition is always false, it's 'then' branch is represented
+  // with a nullptr. Account for this in the predecessors / successors
+  // iteration.
+  template <typename BaseIteratorT> struct skip_null_iterator;
+
+  template <typename BaseIteratorT>
+  using skip_null_iterator_base =
+      llvm::iterator_adaptor_base<skip_null_iterator<BaseIteratorT>,
+                                  BaseIteratorT,
+                                  std::bidirectional_iterator_tag>;
+
+  template <typename BaseIteratorT>
+  struct skip_null_iterator : skip_null_iterator_base<BaseIteratorT> {
+    using Base = skip_null_iterator_base<BaseIteratorT>;
+
+    skip_null_iterator() = default;
+    skip_null_iterator(BaseIteratorT it, BaseIteratorT end)
+        : Base(it), m_end(end) {
+      forward();
+    }
+
+    skip_null_iterator &operator++() {
+      ++this->I;
+      forward();
+      return *this;
+    }
+
+    skip_null_iterator &operator--() {
+      do {
+        --this->I;
+      } while (!*this->I);
+      return *this;
+    }
+
+  private:
+    BaseIteratorT m_end;
+
+    void forward() {
+      while (this->I != m_end && !*this->I)
+        ++this->I;
+    }
+  };
+
+  static auto predecessors(CFGBlock *block) {
+    auto range = llvm::inverse_children<CFGBlock *>(block);
+    using iterator = skip_null_iterator<decltype(range.begin())>;
+    return llvm::make_range(iterator(range.begin(), range.end()),
+                            iterator(range.end(), range.end()));
+  }
+
+  static auto successors(CFGBlock *block) {
+    auto range = llvm::children<CFGBlock *>(block);
+    using iterator = skip_null_iterator<decltype(range.begin())>;
+    return llvm::make_range(iterator(range.begin(), range.end()),
+                            iterator(range.end(), range.end()));
+  }
+};
+
+} // namespace clang
+
+template <> struct llvm::CfgTraitsFor<clang::CFGBlock> {
+  using CfgTraits = clang::CfgTraits;
+};
+
 // FIXME: There is no good reason for the domtree to require a print method
 // which accepts an LLVM Module, so remove this (and the method's argument that
 // needs it) when that is fixed.

llvm/include/llvm/CodeGen/MachineCfgTraits.h

@@ -0,0 +1,171 @@
+//===- MachineCfgTraits.h - Traits for Machine IR CFGs ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines the MachineCfgTraits to allow generic CFG algorithms to
+/// operate on MachineIR in SSA form.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MACHINECFGTRAITS_H
+#define LLVM_CODEGEN_MACHINECFGTRAITS_H
+
+#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/Support/CfgTraits.h"
+
+namespace llvm {
+
+class MachineCfgTraitsBase : public CfgTraitsBase {
+public:
+  using ParentType = MachineFunction;
+  using BlockRef = MachineBasicBlock *;
+  using ValueRef = Register;
+
+  static CfgBlockRef wrapRef(BlockRef block) {
+    return makeOpaque<CfgBlockRefTag>(block);
+  }
+  static CfgValueRef wrapRef(ValueRef value) {
+    // Physical registers are unsupported by design.
+    assert(!value.isValid() || value.isVirtual());
+    uintptr_t wrapped = value.id();
+    assert((wrapped != 0) == value.isValid());
+
+    // Guard against producing values reserved for DenseMap markers. This is de
+    // facto impossible, because it'd require 2^31 virtual registers to be in
+    // use on a 32-bit architecture.
+    assert(wrapped != (uintptr_t)-1 && wrapped != (uintptr_t)-2);
+
+    return makeOpaque<CfgValueRefTag>(reinterpret_cast<void *>(wrapped));
+  }
+  static BlockRef unwrapRef(CfgBlockRef block) {
+    return static_cast<BlockRef>(getOpaque(block));
+  }
+  static ValueRef unwrapRef(CfgValueRef value) {
+    uintptr_t wrapped = reinterpret_cast<uintptr_t>(getOpaque(value));
+    return Register(wrapped);
+  }
+};
+
+/// \brief CFG traits for Machine IR in SSA form.
+class MachineCfgTraits
+    : public CfgTraits<MachineCfgTraitsBase, MachineCfgTraits> {
+private:
+  MachineRegisterInfo *m_regInfo;
+
+public:
+  explicit MachineCfgTraits(MachineFunction *parent)
+      : m_regInfo(&parent->getRegInfo()) {}
+
+  static MachineFunction *getBlockParent(MachineBasicBlock *block) {
+    return block->getParent();
+  }
+
+  struct const_blockref_iterator
+      : iterator_adaptor_base<const_blockref_iterator,
+                              MachineFunction::iterator> {
+    using Base = iterator_adaptor_base<const_blockref_iterator,
+                                       MachineFunction::iterator>;
+
+    const_blockref_iterator() = default;
+
+    explicit const_blockref_iterator(MachineFunction::iterator i) : Base(i) {}
+
+    MachineBasicBlock *operator*() const { return &Base::operator*(); }
+  };
+
+  static iterator_range<const_blockref_iterator>
+  blocks(MachineFunction *function) {
+    return {const_blockref_iterator(function->begin()),
+            const_blockref_iterator(function->end())};
+  }
+
+  static auto predecessors(MachineBasicBlock *block) {
+    return block->predecessors();
+  }
+  static auto successors(MachineBasicBlock *block) {
+    return block->successors();
+  }
+
+  /// Get the defining block of a value.
+  MachineBasicBlock *getValueDefBlock(ValueRef value) const {
+    if (!value)
+      return nullptr;
+    return m_regInfo->getVRegDef(value)->getParent();
+  }
+
+  struct blockdef_iterator
+      : iterator_facade_base<blockdef_iterator, std::forward_iterator_tag,
+                             Register> {
+  private:
+    MachineBasicBlock::instr_iterator m_instr;
+    MachineInstr::mop_iterator m_def;
+
+  public:
+    blockdef_iterator() = default;
+
+    explicit blockdef_iterator(MachineBasicBlock &block)
+        : m_instr(block.instr_begin()) {
+      if (m_instr != block.end())
+        m_def = m_instr->defs().begin();
+    }
+    blockdef_iterator(MachineBasicBlock &block, bool)
+        : m_instr(block.instr_end()), m_def() {}
+
+    bool operator==(const blockdef_iterator &rhs) const {
+      return m_instr == rhs.m_instr && m_def == rhs.m_def;
+    }
+
+    Register operator*() const {
+      assert(m_def->isReg() && !m_def->getSubReg() && m_def->isDef());
+      return m_def->getReg();
+    }
+
+    blockdef_iterator &operator++() {
+      ++m_def;
+
+      while (m_def == m_instr->defs().end()) {
+        ++m_instr;
+        if (m_instr.isEnd()) {
+          m_def = {};
+          return *this;
+        }
+
+        m_def = m_instr->defs().begin();
+      }
+
+      return *this;
+    }
+  };
+
+  static auto blockdefs(MachineBasicBlock *block) {
+    return llvm::make_range(blockdef_iterator(*block),
+                            blockdef_iterator(*block, true));
+  }
+
+  struct Printer {
+    explicit Printer(const MachineCfgTraits &traits)
+        : m_regInfo(traits.m_regInfo) {}
+
+    void printBlockName(raw_ostream &out, MachineBasicBlock *block) const;
+    void printValue(raw_ostream &out, Register value) const;
+
+  private:
+    MachineRegisterInfo *m_regInfo;
+  };
+};
+
+template <> struct CfgTraitsFor<MachineBasicBlock> {
+  using CfgTraits = MachineCfgTraits;
+};
+
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_MACHINECFGTRAITS_H

llvm/include/llvm/IR/CFG.h

@@ -25,6 +25,7 @@
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CfgTraits.h"
 #include <cassert>
 #include <cstddef>
 #include <iterator>
@@ -398,6 +399,98 @@ template <> struct GraphTraits<Inverse<const Function*>> :
   }
 };
 
+//===----------------------------------------------------------------------===//
+// LLVM IR CfgTraits
+//===----------------------------------------------------------------------===//
+
+class IrCfgTraitsBase : public CfgTraitsBase {
+public:
+  using ParentType = Function;
+  using BlockRef = BasicBlock *;
+  using ValueRef = Value *;
+
+  static CfgBlockRef wrapRef(BlockRef block) {
+    return makeOpaque<CfgBlockRefTag>(block);
+  }
+  static CfgValueRef wrapRef(ValueRef block) {
+    return makeOpaque<CfgValueRefTag>(block);
+  }
+  static BlockRef unwrapRef(CfgBlockRef block) {
+    return static_cast<BlockRef>(getOpaque(block));
+  }
+  static ValueRef unwrapRef(CfgValueRef block) {
+    return static_cast<ValueRef>(getOpaque(block));
+  }
+};
+
+/// \brief CFG traits for LLVM IR.
+class IrCfgTraits : public CfgTraits<IrCfgTraitsBase, IrCfgTraits> {
+public:
+  explicit IrCfgTraits(Function * /*parent*/) {}
+
+  static Function *getBlockParent(BasicBlock *block) {
+    return block->getParent();
+  }
+
+  static auto predecessors(BasicBlock *block) {
+    return llvm::predecessors(block);
+  }
+  static auto successors(BasicBlock *block) { return llvm::successors(block); }
+
+  /// Get the defining block of a value if it is an instruction, or null
+  /// otherwise.
+  static BlockRef getValueDefBlock(ValueRef value) {
+    if (auto *instruction = dyn_cast<Instruction>(value))
+      return instruction->getParent();
+    return nullptr;
+  }
+
+  struct block_iterator
+      : iterator_adaptor_base<block_iterator, Function::iterator> {
+    using Base = iterator_adaptor_base<block_iterator, Function::iterator>;
+
+    block_iterator() = default;
+
+    explicit block_iterator(Function::iterator i) : Base(i) {}
+
+    BasicBlock *operator*() const { return &Base::operator*(); }
+  };
+
+  static iterator_range<block_iterator> blocks(Function *function) {
+    return {block_iterator(function->begin()), block_iterator(function->end())};
+  }
+
+  struct value_iterator
+      : iterator_adaptor_base<value_iterator, BasicBlock::iterator> {
+    using Base = iterator_adaptor_base<value_iterator, BasicBlock::iterator>;
+
+    value_iterator() = default;
+
+    explicit value_iterator(BasicBlock::iterator i) : Base(i) {}
+
+    ValueRef operator*() const { return &Base::operator*(); }
+  };
+
+  static iterator_range<value_iterator> blockdefs(BlockRef block) {
+    return {value_iterator(block->begin()), value_iterator(block->end())};
+  }
+
+  struct Printer {
+    explicit Printer(const IrCfgTraits &);
+    ~Printer();
+
+    void printBlockName(raw_ostream &out, BlockRef block) const;
+    void printValue(raw_ostream &out, ValueRef value) const;
+
+  private:
+    mutable std::unique_ptr<ModuleSlotTracker> m_moduleSlotTracker;
+
+    void ensureModuleSlotTracker(const Function &function) const;
+  };
+};
+
+template <> struct CfgTraitsFor<BasicBlock> { using CfgTraits = IrCfgTraits; };
+
 } // end namespace llvm
 
 #endif // LLVM_IR_CFG_H