Bump LLVM

Author: wsmoses

lib/polygeist/Ops.cpp

@@ -675,11 +675,73 @@ struct SelectOfSubIndex : public OpRewritePattern<SelectOp> {
   }
 };
 
+/// Simplify select subindex(x), subindex(y) to subindex(select x, y)
+template<typename T>
+struct LoadSelect : public OpRewritePattern<T> {
+  using OpRewritePattern<T>::OpRewritePattern;
+
+  static Value ptr(T op);
+  static MutableOperandRange ptrMutable(T op);
+
+  LogicalResult matchAndRewrite(T op,
+                                PatternRewriter &rewriter) const override {
+    auto mem0 = ptr(op);
+    SelectOp mem = dyn_cast_or_null<SelectOp>(mem0.getDefiningOp());
+    if (!mem)
+      return failure();
+
+    Type tys[] = {op.getType()};
+    auto iop = rewriter.create<scf::IfOp>(mem.getLoc(), tys, mem.getCondition(), /*hasElse*/true);
+
+    auto vop = cast<T>(op->clone());
+    iop.thenBlock()->push_front(vop);
+    ptrMutable(vop).assign(mem.getTrueValue());
+    rewriter.setInsertionPointToEnd(iop.thenBlock());
+    rewriter.create<scf::YieldOp>(op.getLoc(), vop->getResults());
+    
+    auto eop = cast<T>(op->clone());
+    iop.elseBlock()->push_front(eop);
+    ptrMutable(eop).assign(mem.getFalseValue());
+    rewriter.setInsertionPointToEnd(iop.elseBlock());
+    rewriter.create<scf::YieldOp>(op.getLoc(), eop->getResults());
+
+    rewriter.replaceOp(op, iop.getResults());
+    return success();
+  }
+};
+
+template<>
+  Value LoadSelect<memref::LoadOp>::ptr(memref::LoadOp op) {
+      return op.memref();
+  }
+template<>
+  MutableOperandRange LoadSelect<memref::LoadOp>::ptrMutable(memref::LoadOp op) {
+      return op.memrefMutable();
+  }
+template<>
+  Value LoadSelect<AffineLoadOp>::ptr(AffineLoadOp op) {
+      return op.memref();
+  }
+template<>
+  MutableOperandRange LoadSelect<AffineLoadOp>::ptrMutable(AffineLoadOp op) {
+      return op.memrefMutable();
+  }
+template<>
+  Value LoadSelect<LLVM::LoadOp>::ptr(LLVM::LoadOp op) {
+      return op.getAddr();
+  }
+template<>
+  MutableOperandRange LoadSelect<LLVM::LoadOp>::ptrMutable(LLVM::LoadOp op) {
+      return op.getAddrMutable();
+  }
+
 void SubIndexOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                              MLIRContext *context) {
   results.insert<CastOfSubIndex, SubIndex2, SubToCast, SimplifySubViewUsers,
                  SimplifySubIndexUsers, SelectOfCast, SelectOfSubIndex,
-                 RedundantDynSubIndex>(context);
+                 RedundantDynSubIndex, LoadSelect<memref::LoadOp>,
+                 LoadSelect<AffineLoadOp>, LoadSelect<LLVM::LoadOp>
+                 >(context);
   // Disabled: SubToSubView
 }
 

lib/polygeist/Passes/ConvertPolygeistToLLVM.cpp

@@ -157,7 +157,7 @@ struct Pointer2MemrefOpLowering
     auto result = getStridesAndOffset(op.getType(), strides, offset);
     (void)result;
     assert(succeeded(result) && "unexpected failure in stride computation");
-    assert(!MemRefType::isDynamicStrideOrOffset(offset) &&
+    assert(offset != ShapedType::kDynamicStrideOrOffset &&
            "expected static offset");
 
     bool first = true;
@@ -166,7 +166,7 @@ struct Pointer2MemrefOpLowering
         first = false;
         return false;
       }
-      return MemRefType::isDynamicStrideOrOffset(stride);
+      return stride == ShapedType::kDynamicStrideOrOffset;
     }) && "expected static strides except first element");
 
     descr.setAllocatedPtr(rewriter, loc, ptr);

lib/polygeist/Passes/ParallelLower.cpp

@@ -148,7 +148,7 @@ mlir::LLVM::LLVMFuncOp GetOrCreateMallocFunction(ModuleOp module) {
   mlir::OpBuilder builder(module.getContext());
   SymbolTableCollection symbolTable;
   if (auto fn = dyn_cast_or_null<LLVM::LLVMFuncOp>(
-          symbolTable.lookupSymbolIn(module, builder.getIdentifier("malloc"))))
+          symbolTable.lookupSymbolIn(module, builder.getStringAttr("malloc"))))
     return fn;
   auto ctx = module->getContext();
   mlir::Type types[] = {mlir::IntegerType::get(ctx, 64)};
@@ -164,7 +164,7 @@ mlir::LLVM::LLVMFuncOp GetOrCreateFreeFunction(ModuleOp module) {
   mlir::OpBuilder builder(module.getContext());
   SymbolTableCollection symbolTable;
   if (auto fn = dyn_cast_or_null<LLVM::LLVMFuncOp>(
-          symbolTable.lookupSymbolIn(module, builder.getIdentifier("free"))))
+          symbolTable.lookupSymbolIn(module, builder.getStringAttr("free"))))
     return fn;
   auto ctx = module->getContext();
   auto llvmFnType = LLVM::LLVMFunctionType::get(

llvm-project

@@ -17,7 +17,7 @@ set( LLVM_LINK_COMPONENTS
   Vectorize
 )
 
-add_clang_tool(mlir-clang
+add_clang_executable(mlir-clang
   mlir-clang.cc
   Lib/CGStmt.cc
   "${LLVM_SOURCE_DIR}/../clang/tools/driver/cc1_main.cpp"

tools/mlir-clang/CMakeLists.txt

@@ -1126,10 +1126,11 @@ ValueCategory MLIRScanner::VisitCXXNewExpr(clang::CXXNewExpr *expr) {
   auto ty = getMLIRType(expr->getType());
 
   mlir::Value alloc;
+  mlir::Value arrayCons;
   if (auto mt = ty.dyn_cast<mlir::MemRefType>()) {
     auto shape = std::vector<int64_t>(mt.getShape());
     mlir::Value args[1] = {count};
-    alloc = builder.create<mlir::memref::AllocOp>(loc, mt, args);
+    arrayCons = alloc = builder.create<mlir::memref::AllocOp>(loc, mt, args);
   } else {
     auto i64 = mlir::IntegerType::get(count.getContext(), 64);
     auto typeSize = getTypeSize(expr->getAllocatedType());
@@ -1141,13 +1142,14 @@ ValueCategory MLIRScanner::VisitCXXNewExpr(clang::CXXNewExpr *expr) {
             .create<mlir::LLVM::CallOp>(loc, Glob.GetOrCreateMallocFunction(),
                                         args)
             ->getResult(0));
+    arrayCons = builder.create<mlir::LLVM::BitcastOp>(loc, LLVM::LLVMArrayType::get(ty, 0), alloc);
   }
   assert(alloc);
 
   if (expr->getConstructExpr()) {
     VisitConstructCommon(
         const_cast<CXXConstructExpr *>(expr->getConstructExpr()),
-        /*name*/ nullptr, /*memtype*/ 0, alloc, count);
+        /*name*/ nullptr, /*memtype*/ 0, arrayCons, count);
   }
   return ValueCategory(alloc, /*isRefererence*/ false);
 }
@@ -1305,7 +1307,7 @@ ValueCategory MLIRScanner::VisitConstructCommon(clang::CXXConstructExpr *cons,
 
     builder.setInsertionPointToStart(&forOp.getLoopBody().front());
     assert(obj.isReference);
-    obj.isReference = false;
+    obj = CommonArrayToPointer(obj);
     obj = CommonArrayLookup(obj, forOp.getInductionVar(),
                             /*isImplicitRef*/ false, /*removeIndex*/ false);
     assert(obj.isReference);