[mlir][Analysis] CFGLoopInfo instantiation in C++

[Dinistro]

Summary

This commit moves the CFGLoopInfo instantiation into the C++ file to
ensure that it is only compiled once. Instantiating the template
explicitly revealed two missing functions that this commit also adds.

[gysit]

LGTM but let's give others a chance to have a look at this.

mlir/lib/Analysis/CFGLoopInfo.cpp

12

nit: maybe "Instantiate the LoopBase and LoopInfoBase classes defined in LoopInfoImpl.h for CFGLoops" ?

[Dinistro]

address review comments

[ftynse]

mlir/include/mlir/IR/Block.h

354–357

Not for this commit, but if we are already touching to LoopInfo proper, thi can be refactored to be provided through the trait class, defaulting to return false

[Dinistro]

mlir/include/mlir/IR/Block.h

354–357

Thanks for the comment. I'll check if it makes sense to add this to the GraphTrait or if we should use an SFINAE based mechanism to do this.

mlir/include/mlir/Analysis/CFGLoopInfo.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_LOOPINFO_H
 #define MLIR_ANALYSIS_LOOPINFO_H
 
 #include "mlir/IR/Dominance.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/LoopInfoImpl.h"
+
+namespace mlir {
+class CFGLoop;
+class CFGLoopInfo;
+} // namespace mlir
+
+namespace llvm {
+// Implementation in LLVM's LoopInfoImpl.h
+extern template class LoopBase<mlir::Block, mlir::CFGLoop>;
+extern template class LoopInfoBase<mlir::Block, mlir::CFGLoop>;
+} // namespace llvm
 
 namespace mlir {
 
 /// Representation of a single loop formed by blocks. The inherited LoopBase
 /// class provides accessors to the loop analysis.
 class CFGLoop : public llvm::LoopBase<mlir::Block, mlir::CFGLoop> {
 private:
   explicit CFGLoop(mlir::Block *block);
 
   friend class llvm::LoopBase<mlir::Block, CFGLoop>;
   friend class llvm::LoopInfoBase<mlir::Block, CFGLoop>;
 };
 
 /// An LLVM LoopInfo instantiation for MLIR that provides access to CFG loops
 /// found in the dominator tree.
 class CFGLoopInfo : public llvm::LoopInfoBase<mlir::Block, mlir::CFGLoop> {
 public:
   CFGLoopInfo(const llvm::DominatorTreeBase<mlir::Block, false> &domTree);
 };
+
+raw_ostream &operator<<(raw_ostream &os, mlir::Block &block);
+
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_LOOPINFO_H

mlir/include/mlir/IR/Block.h

public:
   void dump();
 
   /// Print out the name of the block without printing its body.
   /// NOTE: The printType argument is ignored.  We keep it for compatibility
   /// with LLVM dominator machinery that expects it to exist.
   void printAsOperand(raw_ostream &os, bool printType = true);
   void printAsOperand(raw_ostream &os, AsmState &state);
 
+  /// NOTE: Do not call this function, it is only used to be compatible with the
+  /// LLVM loop analysis machinery.
+  bool isLegalToHoistInto() const { return false; };
+
 private:
   /// Pair of the parent object that owns this block and a bit that signifies if
   /// the operations within this block have a valid ordering.
   llvm::PointerIntPair<Region *, /*IntBits=*/1, bool> parentValidOpOrderPair;
 
   /// This is the list of operations in the block.
   OpListType operations;
 

mlir/lib/Analysis/CFGLoopInfo.cpp

 //===- CFGLoopInfo.cpp - LoopInfo analysis for region bodies --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/CFGLoopInfo.h"
+#include "llvm/Analysis/LoopInfoImpl.h"
+
+// Explicitly instantiate the LoopBase and LoopInfoBase classes defined in
+// LoopInfoImpl.h for CFGLoops
+template class llvm::LoopBase<mlir::Block, mlir::CFGLoop>;
+template class llvm::LoopInfoBase<mlir::Block, mlir::CFGLoop>;
 
 using namespace mlir;
 
 CFGLoop::CFGLoop(mlir::Block *block)
     : llvm::LoopBase<mlir::Block, CFGLoop>(block) {}
 
 CFGLoopInfo::CFGLoopInfo(
     const llvm::DominatorTreeBase<mlir::Block, false> &domTree) {
   analyze(domTree);
 }
+
+raw_ostream &mlir::operator<<(raw_ostream &os, mlir::Block &block) {
+  block.print(os);
+  return os;
+}