Merge branch 'main' into fx-mul-libcalls

Author: PiJoules

mlir/lib/Dialect/MLProgram/IR/MLProgramOps.cpp

@@ -178,7 +178,7 @@ LogicalResult GlobalOp::verify() {
 //===----------------------------------------------------------------------===//
 
 GlobalOp GlobalLoadOp::getGlobalOp(SymbolTableCollection &symbolTable) {
-  for (auto parent = getOperation()->getParentOp(); parent;
+  for (auto *parent = getOperation()->getParentOp(); parent;
        parent = parent->getParentOp()) {
     if (auto nearest = symbolTable.lookupNearestSymbolFrom<GlobalOp>(
             parent, getGlobalAttr())) {
@@ -259,7 +259,7 @@ GlobalLoadGraphOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
 //===----------------------------------------------------------------------===//
 
 GlobalOp GlobalStoreOp::getGlobalOp(SymbolTableCollection &symbolTable) {
-  for (auto parent = getOperation()->getParentOp(); parent;) {
+  for (auto *parent = getOperation()->getParentOp(); parent;) {
     if (auto nearest = symbolTable.lookupNearestSymbolFrom<GlobalOp>(
             parent, getGlobalAttr())) {
       return nearest;

mlir/lib/Dialect/MLProgram/Transforms/PipelineGlobalOps.cpp

@@ -29,7 +29,7 @@ class MLProgramPipelineGlobals
 private:
   LogicalResult buildGlobalMap(ModuleOp op);
 
-  void ProcessBlock(Block &block, llvm::DenseSet<SymbolRefAttr> &symbolLoad,
+  void processBlock(Block &block, llvm::DenseSet<SymbolRefAttr> &symbolLoad,
                     llvm::DenseSet<SymbolRefAttr> &symbolStore);
 
   llvm::DenseMap<SymbolRefAttr, llvm::DenseSet<SymbolRefAttr>> loadSymbolsMap;
@@ -38,8 +38,8 @@ class MLProgramPipelineGlobals
 
 // Traverses upwards searchign for the operation mapped by the symbol.
 static Operation *getFromSymbol(Operation *baseOp, SymbolRefAttr symbol) {
-  for (auto op = baseOp; op; op = op->getParentOp()) {
-    auto lookup = SymbolTable::lookupNearestSymbolFrom(op, symbol);
+  for (auto *op = baseOp; op; op = op->getParentOp()) {
+    auto *lookup = SymbolTable::lookupNearestSymbolFrom(op, symbol);
     if (lookup)
       return lookup;
   }
@@ -59,7 +59,7 @@ LogicalResult MLProgramPipelineGlobals::buildGlobalMap(ModuleOp module) {
       }
 
       auto symbol = mlir::dyn_cast<SymbolRefAttr>(callable);
-      auto func = getFromSymbol(op, symbol);
+      auto *func = getFromSymbol(op, symbol);
       callableMap[symbol] = func;
     }
     return WalkResult::advance();
@@ -122,7 +122,7 @@ LogicalResult MLProgramPipelineGlobals::buildGlobalMap(ModuleOp module) {
 
 // Process each operation in the block deleting unneeded loads / stores,
 // recursing on subblocks and checking function calls.
-void MLProgramPipelineGlobals::ProcessBlock(
+void MLProgramPipelineGlobals::processBlock(
     Block &block, llvm::DenseSet<SymbolRefAttr> &symbolLoad,
     llvm::DenseSet<SymbolRefAttr> &symbolStore) {
 
@@ -184,7 +184,7 @@ void MLProgramPipelineGlobals::ProcessBlock(
     llvm::DenseSet<SymbolRefAttr> opSymbolStore;
     for (auto &region : op.getRegions()) {
       for (auto &block : region) {
-        ProcessBlock(block, opSymbolLoad, opSymbolStore);
+        processBlock(block, opSymbolLoad, opSymbolStore);
       }
     }
 
@@ -201,7 +201,7 @@ void MLProgramPipelineGlobals::ProcessBlock(
     }
   }
 
-  for (auto op : toDelete) {
+  for (auto *op : toDelete) {
     op->erase();
   }
 }
@@ -217,7 +217,7 @@ void MLProgramPipelineGlobals::runOnOperation() {
       for (auto &block : region.getBlocks()) {
         llvm::DenseSet<SymbolRefAttr> symbolsLoaded;
         llvm::DenseSet<SymbolRefAttr> symbolsStored;
-        ProcessBlock(block, symbolsLoaded, symbolsStored);
+        processBlock(block, symbolsLoaded, symbolsStored);
       }
     }
   }

mlir/lib/Dialect/NVGPU/TransformOps/NVGPUTransformOps.cpp

@@ -40,7 +40,7 @@ using namespace mlir::transform;
 #define DEBUG_TYPE "nvgpu-transforms"
 #define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE "]: ")
 #define DBGSNL() (llvm::dbgs() << "\n")
-#define LDBG(X) LLVM_DEBUG(DBGS() << X << "\n")
+#define LDBG(X) LLVM_DEBUG(DBGS() << (X) << "\n")
 
 //===----------------------------------------------------------------------===//
 // Apply...ConversionPatternsOp
@@ -606,7 +606,7 @@ struct MmaSyncBuilder {
   /// IndexCalculator callback.
   SmallVector<Value> buildMemRefLoads(OpBuilder &b, Location loc,
                                       OpFoldResult laneId, Value memref,
-                                      IndexCalculator indexFn);
+                                      const IndexCalculator &indexFn);
 
   /// Perform a distributed load of a vector operand of `vectorShape` for a
   /// particular MMA instruction whose `(row, col)` indices are specified via
@@ -625,7 +625,7 @@ struct MmaSyncBuilder {
   SmallVector<Operation *> buildMemRefStores(OpBuilder &b, Location loc,
                                              ValueRange toStore,
                                              OpFoldResult laneId, Value memref,
-                                             IndexCalculator indexFn);
+                                             const IndexCalculator &indexFn);
 
   /// Perform a distributed store of a vector operand of `vectorShape` for a
   /// particular MMA instruction whose `(row, col)` indices are specified via
@@ -660,10 +660,10 @@ static void foreachIndividualVectorElement(Value vector, ApplyFn applyFn,
   }
 }
 
-SmallVector<Value> MmaSyncBuilder::buildMemRefLoads(OpBuilder &b, Location loc,
-                                                    OpFoldResult laneId,
-                                                    Value memref,
-                                                    IndexCalculator indexFn) {
+SmallVector<Value>
+MmaSyncBuilder::buildMemRefLoads(OpBuilder &b, Location loc,
+                                 OpFoldResult laneId, Value memref,
+                                 const IndexCalculator &indexFn) {
   auto aff = [&](AffineExpr e) {
     return affine::makeComposedFoldedAffineApply(b, loc, e, laneId);
   };
@@ -681,7 +681,7 @@ SmallVector<Value> MmaSyncBuilder::buildMemRefLoads(OpBuilder &b, Location loc,
 Value MmaSyncBuilder::buildMmaSyncMemRefLoadOperand(
     OpBuilder &b, Location loc, OpFoldResult laneId, Value memref,
     IndexCalculator indexFn, ArrayRef<int64_t> vectorShape) {
-  auto loads = buildMemRefLoads(b, loc, laneId, memref, indexFn);
+  auto loads = buildMemRefLoads(b, loc, laneId, memref, std::move(indexFn));
 
   Type elementType = getElementTypeOrSelf(memref.getType());
   auto vt = VectorType::get(vectorShape, elementType);
@@ -700,10 +700,9 @@ Value MmaSyncBuilder::buildMmaSyncMemRefLoadOperand(
   return res;
 }
 
-SmallVector<Operation *>
-MmaSyncBuilder::buildMemRefStores(OpBuilder &b, Location loc,
-                                  ValueRange toStore, OpFoldResult laneId,
-                                  Value memref, IndexCalculator indexFn) {
+SmallVector<Operation *> MmaSyncBuilder::buildMemRefStores(
+    OpBuilder &b, Location loc, ValueRange toStore, OpFoldResult laneId,
+    Value memref, const IndexCalculator &indexFn) {
   auto aff = [&](AffineExpr e) {
     return affine::makeComposedFoldedAffineApply(b, loc, e, laneId);
   };
@@ -734,7 +733,7 @@ SmallVector<Operation *> MmaSyncBuilder::buildMmaSyncMemRefStoreOperand(
       [&](Value v, int64_t linearIdx, ArrayRef<int64_t> indices) {
         toStore.push_back(v);
       });
-  return buildMemRefStores(b, loc, toStore, laneId, memref, indexFn);
+  return buildMemRefStores(b, loc, toStore, laneId, memref, std::move(indexFn));
 }
 
 static std::tuple<SmallVector<int64_t>, SmallVector<int64_t>,