[NFC][mlir] Adding some helpful EDSC intrinsics

[ftynse]

mlir/include/mlir/EDSC/Intrinsics.h

208

Please make sure the name corresponds to the instruction name, e.g. ConstantOp should be just constant.

[kernhanda]

constant_data -> constant

[kernhanda]

Someone will have to commit this on my behalf.

[nicolasvasilache]

mlir/include/mlir/EDSC/Intrinsics.h

208

this breaks the build, please fix the other use case:

llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp: In member function ‘virtual mlir::PatternMatchResult {anonymous}::SliceOpConversion::matchAndRewrite(mlir::Operation*, llvm::ArrayRef<mlir::Value>, mlir::ConversionPatternRewriter&) const’:
llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp:268:9: error: reference to ‘constant’ is ambiguous
  268 |         constant(int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0));
      |         ^~~~~~~~
In file included from llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp:20:
llvm-project/mlir/include/mlir/EDSC/Intrinsics.h:203:7: note: candidates are: ‘using constant = struct mlir::edsc::intrinsics::ValueBuilder<mlir::ConstantOp>’
  203 | using constant = ValueBuilder<ConstantOp>;
      |       ^~~~~~~~
llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp:54:7: note:                 ‘using constant = struct mlir::edsc::intrinsics::ValueBuilder<mlir::LLVM::ConstantOp>’
   54 | using constant = ValueBuilder<mlir::LLVM::ConstantOp>;
      |       ^~~~~~~~

[kernhanda]

fixing build fix

[kernhanda]

ran clang-format

[kernhanda]

mlir/include/mlir/EDSC/Intrinsics.h

208

Thanks for catching this.

[kernhanda]

Ping. :) Someone will also have to commit this on my behalf.

[nicolasvasilache]

My apologies for the delay..
Also, please note that https://github.com/llvm/llvm-project/commit/75394e1301dd1d4739a24d440e9996c52e5b5570#diff-6635fa1a5b0b10edf6e511585c7c986d refactored things significantly on the EDSC front so this would need a rebase.

[kernhanda]

Rebased

[nicolasvasilache]

Thank you!

mlir/include/mlir/EDSC/Intrinsics.h

public:
   }
   operator ArrayRef<Value>() { return values; }
 
 private:
   ValueHandleArray() = default;
   SmallVector<Value, 8> values;
 };
 
-template <typename T> inline T unpack(T value) { return value; }
+template <typename T>
+inline T unpack(T value) {
+  return value;
+}
 
 inline detail::ValueHandleArray unpack(ArrayRef<ValueHandle> values) {
   return detail::ValueHandleArray(values);
 }
 
 } // namespace detail
 
 /// Helper variadic abstraction to allow extending to any MLIR op without
 /// boilerplate or Tablegen.
 /// Arguably a builder is not a ValueHandle but in practice it is only used as
 /// an alias to a notional ValueHandle<Op>.
 /// Implementing it as a subclass allows it to compose all the way to Value.
 /// Without subclassing, implicit conversion to Value would fail when composing
 /// in patterns such as: `select(a, b, select(c, d, e))`.
-template <typename Op> struct ValueBuilder : public ValueHandle {
+template <typename Op>
+struct ValueBuilder : public ValueHandle {
   // Builder-based
   template <typename... Args>
   ValueBuilder(Args... args)
       : ValueHandle(ValueHandle::create<Op>(detail::unpack(args)...)) {}
   ValueBuilder(ArrayRef<ValueHandle> vs)
       : ValueBuilder(ValueBuilder::create<Op>(detail::unpack(vs))) {}
   template <typename... Args>
   ValueBuilder(ArrayRef<ValueHandle> vs, Args... args)
ValueBuilder(OperationFolder *folder, T1 t1, T2 t2, ArrayRef<ValueHandle> vs,
                Args... args)
       : ValueHandle(ValueHandle::create<Op>(
             folder, detail::unpack(t1), detail::unpack(t2), detail::unpack(vs),
             detail::unpack(args)...)) {}
 
   ValueBuilder() : ValueHandle(ValueHandle::create<Op>()) {}
 };
 
-template <typename Op> struct OperationBuilder : public OperationHandle {
+template <typename Op>
+struct OperationBuilder : public OperationHandle {
   template <typename... Args>
   OperationBuilder(Args... args)
       : OperationHandle(OperationHandle::create<Op>(detail::unpack(args)...)) {}
   OperationBuilder(ArrayRef<ValueHandle> vs)
       : OperationHandle(OperationHandle::create<Op>(detail::unpack(vs))) {}
   template <typename... Args>
   OperationBuilder(ArrayRef<ValueHandle> vs, Args... args)
       : OperationHandle(OperationHandle::create<Op>(detail::unpack(vs),

 using affine_apply = ValueBuilder<AffineApplyOp>;
 using affine_if = OperationBuilder<AffineIfOp>;
 using affine_load = ValueBuilder<AffineLoadOp>;
 using affine_min = ValueBuilder<AffineMinOp>;
 using affine_max = ValueBuilder<AffineMaxOp>;
 using affine_store = OperationBuilder<AffineStoreOp>;
 using alloc = ValueBuilder<AllocOp>;
 using call = OperationBuilder<mlir::CallOp>;
+using constant = ValueBuilder<ConstantOp>;
 using constant_float = ValueBuilder<ConstantFloatOp>;
 using constant_index = ValueBuilder<ConstantIndexOp>;
 using constant_int = ValueBuilder<ConstantIntOp>;
 using dealloc = OperationBuilder<DeallocOp>;
 using dim = ValueBuilder<DimOp>;
+using extract_element = ValueBuilder<ExtractElementOp>;
+using index_cast = ValueBuilder<IndexCastOp>;
 using muli = ValueBuilder<MulIOp>;
 using mulf = ValueBuilder<MulFOp>;
 using memref_cast = ValueBuilder<MemRefCastOp>;
 using ret = OperationBuilder<ReturnOp>;
 using select = ValueBuilder<SelectOp>;
 using std_load = ValueBuilder<LoadOp>;
 using std_store = OperationBuilder<StoreOp>;
 using subi = ValueBuilder<SubIOp>;
+using sub_view = ValueBuilder<SubViewOp>;
 using tanh = ValueBuilder<TanhOp>;
+using tensor_load = ValueBuilder<TensorLoadOp>;
+using tensor_store = OperationBuilder<TensorStoreOp>;
 using view = ValueBuilder<ViewOp>;
 using zero_extendi = ValueBuilder<ZeroExtendIOp>;
 using sign_extendi = ValueBuilder<SignExtendIOp>;
 
 /// Branches into the mlir::Block* captured by BlockHandle `b` with `operands`.
 ///
 /// Prerequisites:
 ///   All Handles have already captured previously constructed IR objects.

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 using namespace mlir::edsc::intrinsics;
 using namespace mlir::LLVM;
 using namespace mlir::linalg;
 
 using add = ValueBuilder<mlir::LLVM::AddOp>;
 using addi = ValueBuilder<mlir::AddIOp>;
 using bitcast = ValueBuilder<mlir::LLVM::BitcastOp>;
 using cmpi = ValueBuilder<mlir::CmpIOp>;
-using constant = ValueBuilder<mlir::LLVM::ConstantOp>;
+using llvm_constant = ValueBuilder<mlir::LLVM::ConstantOp>;
 using extractvalue = ValueBuilder<mlir::LLVM::ExtractValueOp>;
 using gep = ValueBuilder<mlir::LLVM::GEPOp>;
 using insertvalue = ValueBuilder<mlir::LLVM::InsertValueOp>;
 using llvm_call = OperationBuilder<mlir::LLVM::CallOp>;
 using llvm_icmp = ValueBuilder<LLVM::ICmpOp>;
 using llvm_load = ValueBuilder<LLVM::LoadOp>;
 using llvm_store = OperationBuilder<LLVM::StoreOp>;
 using llvm_select = ValueBuilder<LLVM::SelectOp>;
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
 
     // Insert base offset.
     desc.setOffset(baseOffset);
 
     // Corner case, no sizes or strides: early return the descriptor.
     if (sliceOp.getShapedType().getRank() == 0)
       return rewriter.replaceOp(op, {desc}), matchSuccess();
 
-    Value zero =
-        constant(int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0));
+    Value zero = llvm_constant(
+        int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0));
     // Compute and insert view sizes (max - min along the range) and strides.
     // Skip the non-range operands as they will be projected away from the view.
     int numNewDims = 0;
     for (auto en : llvm::enumerate(sliceOp.indexings())) {
       Value indexing = en.value();
       if (indexing.getType().isa<RangeType>()) {
         int rank = en.index();
         Value rangeDescriptor = adaptor.indexings()[rank];