[mlir][Standard] NFC - Drop remaining EDSC usage

[nicolasvasilache]

Summary

Drop the remaining EDSC subdirectories and update all uses.

[ftynse]

Nice cleanup!

flang/tools/tco/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 set(LIBS
   FIROptimizer
   ${dialect_libs}
   MLIRIR
   MLIRLLVMIR
   MLIRPass
   MLIRStandardToLLVM
   MLIRTransforms
   MLIRAffineToStandard
   MLIRAnalysis
   MLIRSCFToStandard
-  MLIREDSC
   MLIRParser
   MLIRStandardToLLVM
   MLIRSupport
   MLIRVectorToLLVM
 )
 
 add_flang_tool(tco tco.cpp)
 target_link_libraries(tco PRIVATE ${LIBS})

mlir/docs/EDSC.md

-# Background: declarative builders API
-
-The main purpose of the declarative builders API is to provide an intuitive way
-of constructing MLIR programmatically. In the majority of cases, the IR we wish
-to construct exhibits structured control-flow. The Declarative builders in the
-`EDSC` library (Embedded Domain Specific Constructs) provide an API to make MLIR
-construction and manipulation very idiomatic, for the structured control-flow
-case, in C++.
-
-## ScopedContext
-
-`mlir::edsc::ScopedContext` provides an implicit thread-local context,
-supporting a simple declarative API with globally accessible builders. These
-declarative builders are available within the lifetime of a `ScopedContext`.
-
-## Intrinsics
-
-`mlir::ValueBuilder` is a generic wrapper for the `mlir::OpBuilder::create`
-method that operates on `Value` objects and return a single Value. For
-instructions that return no values or that return multiple values, the
-`mlir::edsc::OperationBuilder` can be used. Named intrinsics are provided as
-syntactic sugar to further reduce boilerplate.
-
-```c++
-using load = ValueBuilder<LoadOp>;
-using store = OperationBuilder<StoreOp>;
-```
-
-## LoopBuilder and AffineLoopNestBuilder
-
-`mlir::edsc::AffineLoopNestBuilder` provides an interface to allow writing
-concise and structured loop nests.
-
-```c++
-  ScopedContext scope(f.get());
-  Value i, j, lb(f->getArgument(0)), ub(f->getArgument(1));
-  Value f7(std_constant_float(llvm::APFloat(7.0f), f32Type)),
-           f13(std_constant_float(llvm::APFloat(13.0f), f32Type)),
-           i7(constant_int(7, 32)),
-           i13(constant_int(13, 32));
-  AffineLoopNestBuilder(&i, lb, ub, 3)([&]{
-      lb * index_type(3) + ub;
-      lb + index_type(3);
-      AffineLoopNestBuilder(&j, lb, ub, 2)([&]{
-          ceilDiv(index_type(31) * floorDiv(i + j * index_type(3), index_type(32)),
-                  index_type(32));
-          ((f7 + f13) / f7) % f13 - f7 * f13;
-          ((i7 + i13) / i7) % i13 - i7 * i13;
-      });
-  });
-```
-
-## IndexedValue
-
-`mlir::edsc::IndexedValue` provides an index notation around load and store
-operations on abstract data types by overloading the C++ assignment and
-parenthesis operators. The relevant loads and stores are emitted as appropriate.
-
-## Putting it all together
-
-With declarative builders, it becomes fairly concise to build rank and
-type-agnostic custom operations even though MLIR does not yet have generic
-types. Here is what a definition of a general pointwise add looks in
-Tablegen with declarative builders.
-
-```c++
-def AddOp : Op<"x.add">,
-    Arguments<(ins Tensor:$A, Tensor:$B)>,
-    Results<(outs Tensor: $C)> {
-  code referenceImplementation = [{
-    SmallVector<Value, 4> ivs(view_A.rank());
-    IndexedValue A(arg_A), B(arg_B), C(arg_C);
-    AffineLoopNestBuilder(
-      ivs, view_A.getLbs(), view_A.getUbs(), view_A.getSteps())([&]{
-        C(ivs) = A(ivs) + B(ivs)
-      });
-  }];
-}
-```
-
-Depending on the function signature on which this emitter is called, the
-generated IR resembles the following, for a 4-D memref of `vector<4xi8>`:
-
-```
-// CHECK-LABEL: func @t1(%lhs: memref<3x4x5x6xvector<4xi8>>, %rhs: memref<3x4x5x6xvector<4xi8>>, %result: memref<3x4x5x6xvector<4xi8>>) -> () {
-//       CHECK: affine.for {{.*}} = 0 to 3 {
-//       CHECK:   affine.for {{.*}} = 0 to 4 {
-//       CHECK:     affine.for {{.*}} = 0 to 5 {
-//       CHECK:       affine.for {{.*}}= 0 to 6 {
-//       CHECK:         {{.*}} = load %arg1[{{.*}}] : memref<3x4x5x6xvector<4xi8>>
-//       CHECK:         {{.*}} = load %arg0[{{.*}}] : memref<3x4x5x6xvector<4xi8>>
-//       CHECK:         {{.*}} = addi {{.*}} : vector<4xi8>
-//       CHECK:         store {{.*}}, %arg2[{{.*}}] : memref<3x4x5x6xvector<4xi8>>
-```
-
-or the following, for a 0-D `memref<f32>`:
-
-```
-// CHECK-LABEL: func @t3(%lhs: memref<f32>, %rhs: memref<f32>, %result: memref<f32>) -> () {
-//       CHECK: {{.*}} = load %arg1[] : memref<f32>
-//       CHECK: {{.*}} = load %arg0[] : memref<f32>
-//       CHECK: {{.*}} = addf {{.*}}, {{.*}} : f32
-//       CHECK: store {{.*}}, %arg2[] : memref<f32>
-```
-
-Similar APIs are provided to emit the lower-level `scf.for` op with
-`LoopNestBuilder`. See the `builder-api-test.cpp` test for more usage examples.
-
-Since the implementation of declarative builders is in C++, it is also available
-to program the IR with an embedded-DSL flavor directly integrated in MLIR.

mlir/docs/OpDefinitions.md

*   TableGen is a modelling specification language used by LLVM's backends
         and fits in well with trait-based modelling. This is an implementation
         decision and there are alternative ways of doing this. But the
         specification language is good for the requirements of modelling the
         traits (as seen from usage in LLVM processor backend modelling) and easy
         to extend, so a practical choice. If another good option comes up, we
         will consider it.
 *   MLIR allows both defined and undefined ops.
     *   Defined ops should have fixed semantics and could have a corresponding
-        reference implementation defined using, for example, EDSC.
+        reference implementation defined.
     *   Dialects are under full control of the dialect owner and normally live
         with the framework of the dialect.
 *   The op's traits (e.g., commutative) are modelled along with the op in the
     registry.
 *   The op's operand/return type constraints are modelled along with the op in
     the registry (see [Shape inference](ShapeInference.md) discussion below),
     this allows (e.g.) optimized concise syntax in textual dumps.
 *   Behavior of the op is documented along with the op with a summary and a

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

 //===- Utils.h - Utilities to support the Linalg dialect --------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LINALG_UTILS_H_
 #define MLIR_DIALECT_LINALG_UTILS_H_
 
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/SCF/SCF.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 
 namespace mlir {
 class AffineExpr;
 class AffineForOp;
 class AffineMap;

mlir/include/mlir/Dialect/Math/EDSC/Intrinsics.h

-//===- Intrinsics.h - MLIR EDSC Intrinsics for Math ops ---------*- 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
-//
-//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_MATH_EDSC_INTRINSICS_H_
-#define MLIR_DIALECT_MATH_EDSC_INTRINSICS_H_
-
-#include "mlir/Dialect/Math/IR/Math.h"
-#include "mlir/EDSC/Builders.h"
-
-namespace mlir {
-namespace edsc {
-namespace intrinsics {
-
-using math_rsqrt = ValueBuilder<math::RsqrtOp>;
-using math_tanh = ValueBuilder<math::TanhOp>;
-
-} // namespace intrinsics
-} // namespace edsc
-} // namespace mlir
-
-#endif // MLIR_DIALECT_MATH_EDSC_INTRINSICS_H_

mlir/include/mlir/Dialect/StandardOps/EDSC/Builders.h

-//===- Builders.h - MLIR EDSC Builders for StandardOps ----------*- 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
-//
-//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_STANDARDOPS_EDSC_BUILDERS_H_
-#define MLIR_DIALECT_STANDARDOPS_EDSC_BUILDERS_H_
-
-#include "mlir/Dialect/StandardOps/IR/Ops.h"
-#include "mlir/EDSC/Builders.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/Types.h"
-
-namespace mlir {
-namespace edsc {
-
-/// Base class for MemRefBoundsCapture and VectorBoundsCapture.
-class BoundsCapture {
-public:
-  unsigned rank() const { return lbs.size(); }
-  Value lb(unsigned idx) const { return lbs[idx]; }
-  Value ub(unsigned idx) const { return ubs[idx]; }
-  int64_t step(unsigned idx) const { return steps[idx]; }
-  std::tuple<Value, Value, int64_t> range(unsigned idx) const {
-    return std::make_tuple(lbs[idx], ubs[idx], steps[idx]);
-  }
-  void swapRanges(unsigned i, unsigned j) {
-    if (i == j)
-      return;
-    std::swap(lbs[i], lbs[j]);
-    std::swap(ubs[i], ubs[j]);
-    std::swap(steps[i], steps[j]);
-  }
-
-  ArrayRef<Value> getLbs() const { return lbs; }
-  ArrayRef<Value> getUbs() const { return ubs; }
-  ArrayRef<int64_t> getSteps() const { return steps; }
-
-protected:
-  SmallVector<Value, 8> lbs;
-  SmallVector<Value, 8> ubs;
-  SmallVector<int64_t, 8> steps;
-};
-
-/// A VectorBoundsCapture represents the information required to step through a
-/// Vector accessing each scalar element at a time. It is the counterpart of
-/// a MemRefBoundsCapture but for vectors. This exists purely for boilerplate
-/// avoidance.
-class VectorBoundsCapture : public BoundsCapture {
-public:
-  explicit VectorBoundsCapture(Value v);
-  explicit VectorBoundsCapture(VectorType t);
-
-private:
-  Value base;
-};
-
-} // namespace edsc
-} // namespace mlir
-
-#endif // MLIR_DIALECT_STANDARDOPS_EDSC_BUILDERS_H_

mlir/include/mlir/Dialect/StandardOps/EDSC/Intrinsics.h

-//===- Intrinsics.h - MLIR EDSC Intrinsics for StandardOps ------*- 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
-//
-//===----------------------------------------------------------------------===//
-#ifndef MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_
-#define MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_
-
-#include "mlir/Dialect/StandardOps/EDSC/Builders.h"
-#include "mlir/Dialect/Tensor/IR/Tensor.h"
-
-namespace mlir {
-namespace edsc {
-namespace intrinsics {
-
-using std_addi = ValueBuilder<AddIOp>;
-using std_addf = ValueBuilder<AddFOp>;
-using std_call = OperationBuilder<CallOp>;
-using std_constant = ValueBuilder<ConstantOp>;
-using std_constant_float = ValueBuilder<ConstantFloatOp>;
-using std_constant_index = ValueBuilder<ConstantIndexOp>;
-using std_constant_int = ValueBuilder<ConstantIntOp>;
-using std_divis = ValueBuilder<SignedDivIOp>;
-using std_diviu = ValueBuilder<UnsignedDivIOp>;
-using std_fpext = ValueBuilder<FPExtOp>;
-using std_fptrunc = ValueBuilder<FPTruncOp>;
-using std_index_cast = ValueBuilder<IndexCastOp>;
-using std_muli = ValueBuilder<MulIOp>;
-using std_mulf = ValueBuilder<MulFOp>;
-using std_ret = OperationBuilder<ReturnOp>;
-using std_select = ValueBuilder<SelectOp>;
-using std_sign_extendi = ValueBuilder<SignExtendIOp>;
-using std_splat = ValueBuilder<SplatOp>;
-using std_subf = ValueBuilder<SubFOp>;
-using std_subi = ValueBuilder<SubIOp>;
-using std_zero_extendi = ValueBuilder<ZeroExtendIOp>;
-using tensor_extract = ValueBuilder<tensor::ExtractOp>;
-
-template <int N>
-struct SExtiValueBuilder : public ValueBuilder<SignExtendIOp> {
-  using ValueBuilder<SignExtendIOp>::ValueBuilder;
-  template <typename... Args>
-  SExtiValueBuilder(Args... args)
-      : ValueBuilder<SignExtendIOp>(ScopedContext::getBuilderRef().getI32Type(),
-                                    args...) {}
-};
-
-using std_sexti32 = SExtiValueBuilder<32>;
-
-template <CmpFPredicate Predicate>
-struct CmpFValueBuilder : public ValueBuilder<CmpFOp> {
-  using ValueBuilder<CmpFOp>::ValueBuilder;
-  template <typename... Args>
-  CmpFValueBuilder(Args... args) : ValueBuilder<CmpFOp>(Predicate, args...) {}
-};
-
-using std_cmpf_ogt = CmpFValueBuilder<CmpFPredicate::OGT>;
-using std_cmpf_olt = CmpFValueBuilder<CmpFPredicate::OLT>;
-
-template <CmpIPredicate Predicate>
-struct CmpIValueBuilder : public ValueBuilder<CmpIOp> {
-  using ValueBuilder<CmpIOp>::ValueBuilder;
-  template <typename... Args>
-  CmpIValueBuilder(Args... args) : ValueBuilder<CmpIOp>(Predicate, args...) {}
-};
-
-using std_cmpi_sgt = CmpIValueBuilder<CmpIPredicate::sgt>;
-
-/// Branches into `block` with `operands`.
-BranchOp std_br(Block *block, ValueRange operands);
-
-/// Branches into `trueBranch` with `trueOperands` if `cond` evaluates to `true`
-/// or to `falseBranch` and `falseOperand` if `cond` evaluates to `false`.
-CondBranchOp std_cond_br(Value cond, Block *trueBranch, ValueRange trueOperands,
-                         Block *falseBranch, ValueRange falseOperands);
-} // namespace intrinsics
-} // namespace edsc
-} // namespace mlir
-
-#endif // MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_

mlir/include/mlir/EDSC/Builders.h

-//===- Builders.h - MLIR Declarative Builder Classes ------------*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Provides intuitive composable interfaces for building structured MLIR
-// snippets in a declarative fashion.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_EDSC_BUILDERS_H_
-#define MLIR_EDSC_BUILDERS_H_
-
-#include "mlir/IR/AffineExpr.h"
-#include "mlir/IR/Builders.h"
-#include "mlir/IR/BuiltinTypes.h"
-#include "mlir/IR/Types.h"
-
-namespace mlir {
-class OperationFolder;
-
-namespace edsc {
-/// Helper class to transparently handle builder insertion points by RAII.
-/// As its name indicates, a ScopedContext is means to be used locally in a
-/// scoped fashion. This abstracts away all the boilerplate related to
-/// checking proper usage of captures, NestedBuilders as well as handling the
-/// setting and restoring of insertion points.
-class ScopedContext {
-public:
-  ScopedContext(OpBuilder &b);
-  ScopedContext(OpBuilder &b, Location location);
-
-  /// Sets the insertion point of the builder to 'newInsertPt' for the duration
-  /// of the scope. The existing insertion point of the builder is restored on
-  /// destruction.
-  ScopedContext(OpBuilder &b, OpBuilder::InsertPoint newInsertPt,
-                Location location);
-  ~ScopedContext();
-
-  static MLIRContext *getContext();
-  static OpBuilder &getBuilderRef();
-  static Location getLocation();
-
-private:
-  /// Only NestedBuilder (which is used to create an operation with a body)
-  /// may access private members in order to implement scoping.
-  friend class NestedBuilder;
-
-  ScopedContext() = delete;
-  ScopedContext(const ScopedContext &) = delete;
-  ScopedContext &operator=(const ScopedContext &) = delete;
-
-  static ScopedContext *&getCurrentScopedContext();
-
-  /// Top level OpBuilder.
-  OpBuilder &builder;
-  /// Guard to the previous insertion point.
-  OpBuilder::InsertionGuard guard;
-  /// Current location.
-  Location location;
-  /// Parent context we return into.
-  ScopedContext *enclosingScopedContext;
-};
-
-template <typename Op>
-struct ValueBuilder {
-  template <typename... Args>
-  ValueBuilder(Args... args) {
-    value = ScopedContext::getBuilderRef()
-                .create<Op>(ScopedContext::getLocation(), args...)
-                .getResult();
-  }
-  operator Value() { return value; }
-  Value value;
-};
-
-template <typename Op>
-struct OperationBuilder {
-  template <typename... Args>
-  OperationBuilder(Args... args) {
-    op = ScopedContext::getBuilderRef().create<Op>(ScopedContext::getLocation(),
-                                                   args...);
-  }
-  operator Op() { return op; }
-  operator Operation *() { return op.getOperation(); }
-  Op op;
-};
-
-/// Creates a block in the region that contains the insertion block of the
-/// OpBuilder currently at the top of ScopedContext stack (appends the block to
-/// the region). Be aware that this will NOT update the insertion point of the
-/// builder to insert into the newly constructed block.
-Block *createBlock(TypeRange argTypes = llvm::None);
-
-/// Creates a block in the specified region using OpBuilder at the top of
-/// ScopedContext stack (appends the block to the region). Be aware that this
-/// will NOT update the insertion point of the builder to insert into the newly
-/// constructed block.
-Block *createBlockInRegion(Region &region, TypeRange argTypes = llvm::None);
-
-/// Calls "builderFn" with ScopedContext reconfigured to insert into "block" and
-/// passes in the block arguments. If the block has a terminator, the operations
-/// are inserted before the terminator, otherwise appended to the block.
-void appendToBlock(Block *block, function_ref<void(ValueRange)> builderFn);
-
-/// Creates a block in the region that contains the insertion block of the
-/// OpBuilder currently at the top of ScopedContext stack, and calls "builderFn"
-/// to populate the body of the block while passing it the block arguments.
-Block *buildInNewBlock(TypeRange argTypes,
-                       function_ref<void(ValueRange)> builderFn);
-
-/// Creates a block in the specified region using OpBuilder at the top of
-/// ScopedContext stack, and calls "builderFn" to populate the body of the block
-/// while passing it the block arguments.
-Block *buildInNewBlock(Region &region, TypeRange argTypes,
-                       function_ref<void(ValueRange)> builderFn);
-
-/// A StructuredIndexed represents an indexable quantity that is either:
-/// 1. a captured value, which is suitable for buffer and tensor operands, or;
-/// 2. a captured type, which is suitable for tensor return values.
-///
-/// A StructuredIndexed itself is indexed and passed to `makeGenericLinalgOp`.
-/// It enable an idiomatic syntax for index expressions such as:
-///
-/// ```
-///      StructuredIndexed A(buffer_or_tensor_value), B(buffer_or_tensor_value),
-///        C(buffer_value_or_tensor_type);
-///      makeGenericLinalgOp({A({m, n}), B({k, n})}, {C({m, n})}, ... );
-/// ```
-struct StructuredIndexed {
-  StructuredIndexed(Value v) : value(v) {}
-  StructuredIndexed(Type t) : type(t) {}
-  StructuredIndexed operator()(ArrayRef<AffineExpr> indexings) {
-    return value ? StructuredIndexed(value, indexings)
-                 : StructuredIndexed(type, indexings);
-  }
-
-  StructuredIndexed(Value v, ArrayRef<AffineExpr> indexings)
-      : value(v), exprs(indexings.begin(), indexings.end()) {
-    assert((v.getType().isa<MemRefType, RankedTensorType, VectorType>()) &&
-           "MemRef, RankedTensor or Vector expected");
-  }
-  StructuredIndexed(Type t, ArrayRef<AffineExpr> indexings)
-      : type(t), exprs(indexings.begin(), indexings.end()) {
-    assert((t.isa<MemRefType, RankedTensorType, VectorType>()) &&
-           "MemRef, RankedTensor or Vector expected");
-  }
-
-  bool hasValue() const { return (bool)value; }
-  Value getValue() const {
-    assert(value && "StructuredIndexed Value not set.");
-    return value;
-  }
-  Type getType() const {
-    assert((value || type) && "StructuredIndexed Value and Type not set.");
-    return value ? value.getType() : type;
-  }
-  ArrayRef<AffineExpr> getExprs() const { return exprs; }
-  operator Value() const { return getValue(); }
-  operator Type() const { return getType(); }
-
-private:
-  // Only one of Value or type may be set.
-  Type type;
-  Value value;
-  SmallVector<AffineExpr, 4> exprs;
-};
-
-} // namespace edsc
-} // namespace mlir
-
-#endif // MLIR_EDSC_BUILDERS_H_

mlir/lib/CMakeLists.txt

 # Enable errors for any global constructors.
 add_flag_if_supported("-Werror=global-constructors" WERROR_GLOBAL_CONSTRUCTOR)
 
 add_subdirectory(Analysis)
 add_subdirectory(Bindings)
 add_subdirectory(Conversion)
 add_subdirectory(Dialect)
-add_subdirectory(EDSC)
 add_subdirectory(ExecutionEngine)
 add_subdirectory(IR)
 add_subdirectory(Interfaces)
 add_subdirectory(Parser)
 add_subdirectory(Pass)
 add_subdirectory(Reducer)
 add_subdirectory(Rewrite)
 add_subdirectory(Support)
 add_subdirectory(TableGen)
 add_subdirectory(Target)
 add_subdirectory(Tools)
 add_subdirectory(Transforms)
 add_subdirectory(Translation)

mlir/lib/Conversion/LinalgToLLVM/CMakeLists.txt

 add_mlir_conversion_library(MLIRLinalgToLLVM
   LinalgToLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/LinalgToLLVM
 
   DEPENDS
   MLIRConversionPassIncGen
   MLIRLinalgPassIncGen
   intrinsics_gen
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
   MLIRAffineToStandard
-  MLIREDSC
   MLIRIR
   MLIRLinalg
   MLIRLLVMIR
   MLIRSCFToStandard
   MLIRStandardToLLVM
   MLIRTransforms
   MLIRVectorToLLVM
   MLIRVectorToSCF
   )

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/SCF/SCF.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::LLVM;
 using namespace mlir::linalg;
 
-using llvm_add = ValueBuilder<LLVM::AddOp>;
-using llvm_bitcast = ValueBuilder<LLVM::BitcastOp>;
-using llvm_constant = ValueBuilder<LLVM::ConstantOp>;
-using llvm_extractvalue = ValueBuilder<LLVM::ExtractValueOp>;
-using llvm_gep = ValueBuilder<LLVM::GEPOp>;
-using llvm_insertvalue = ValueBuilder<LLVM::InsertValueOp>;
-using llvm_call = OperationBuilder<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>;
-using llvm_mul = ValueBuilder<LLVM::MulOp>;
-using llvm_ptrtoint = ValueBuilder<LLVM::PtrToIntOp>;
-using llvm_sub = ValueBuilder<LLVM::SubOp>;
-using llvm_undef = ValueBuilder<LLVM::UndefOp>;
-using llvm_urem = ValueBuilder<LLVM::URemOp>;
-using llvm_alloca = ValueBuilder<LLVM::AllocaOp>;
-using llvm_return = OperationBuilder<LLVM::ReturnOp>;
-
 template <typename T>
 static Type getPtrToElementType(T containerType, LLVMTypeConverter &lowering) {
   return LLVMPointerType::get(
       lowering.convertType(containerType.getElementType()));
 }
 
 /// Convert the given range descriptor type to the LLVMIR dialect.
 /// Range descriptor contains the range bounds and the step as 64-bit integers.
 ///
 /// struct {
 ///   int64_t min;
 ///   int64_t max;
 ///   int64_t step;
 /// };
 static Type convertRangeType(RangeType t, LLVMTypeConverter &converter) {
   auto *context = t.getContext();
   auto int64Ty = converter.convertType(IntegerType::get(context, 64));
   return LLVMStructType::getLiteral(context, {int64Ty, int64Ty, int64Ty});
 }
 
 namespace {
-/// EDSC-compatible wrapper for MemRefDescriptor.
-class BaseViewConversionHelper {
-public:
-  BaseViewConversionHelper(Type type)
-      : d(MemRefDescriptor::undef(rewriter(), loc(), type)) {}
-
-  BaseViewConversionHelper(Value v) : d(v) {}
-
-  /// Wrappers around MemRefDescriptor that use EDSC builder and location.
-  Value allocatedPtr() { return d.allocatedPtr(rewriter(), loc()); }
-  void setAllocatedPtr(Value v) { d.setAllocatedPtr(rewriter(), loc(), v); }
-  Value alignedPtr() { return d.alignedPtr(rewriter(), loc()); }
-  void setAlignedPtr(Value v) { d.setAlignedPtr(rewriter(), loc(), v); }
-  Value offset() { return d.offset(rewriter(), loc()); }
-  void setOffset(Value v) { d.setOffset(rewriter(), loc(), v); }
-  Value size(unsigned i) { return d.size(rewriter(), loc(), i); }
-  void setSize(unsigned i, Value v) { d.setSize(rewriter(), loc(), i, v); }
-  void setConstantSize(unsigned i, int64_t v) {
-    d.setConstantSize(rewriter(), loc(), i, v);
-  }
-  Value stride(unsigned i) { return d.stride(rewriter(), loc(), i); }
-  void setStride(unsigned i, Value v) { d.setStride(rewriter(), loc(), i, v); }
-  void setConstantStride(unsigned i, int64_t v) {
-    d.setConstantStride(rewriter(), loc(), i, v);
-  }
-
-  operator Value() { return d; }
-
-private:
-  OpBuilder &rewriter() { return ScopedContext::getBuilderRef(); }
-  Location loc() { return ScopedContext::getLocation(); }
-
-  MemRefDescriptor d;
-};
-
 // RangeOp creates a new range descriptor.
 class RangeOpConversion : public ConvertOpToLLVMPattern<RangeOp> {
 public:
   using ConvertOpToLLVMPattern<RangeOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(RangeOp rangeOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto rangeDescriptorTy = convertRangeType(
         rangeOp.getType().cast<RangeType>(), *getTypeConverter());
 
-    edsc::ScopedContext context(rewriter, rangeOp->getLoc());
+    ImplicitLocOpBuilder b(rangeOp->getLoc(), rewriter);
 
     // Fill in an aggregate value of the descriptor.
     RangeOpAdaptor adaptor(operands);
-    Value desc = llvm_undef(rangeDescriptorTy);
-    desc = llvm_insertvalue(desc, adaptor.min(), rewriter.getI64ArrayAttr(0));
-    desc = llvm_insertvalue(desc, adaptor.max(), rewriter.getI64ArrayAttr(1));
-    desc = llvm_insertvalue(desc, adaptor.step(), rewriter.getI64ArrayAttr(2));
+    Value desc = b.create<LLVM::UndefOp>(rangeDescriptorTy);
+    desc = b.create<LLVM::InsertValueOp>(desc, adaptor.min(),
+                                         rewriter.getI64ArrayAttr(0));
+    desc = b.create<LLVM::InsertValueOp>(desc, adaptor.max(),
+                                         rewriter.getI64ArrayAttr(1));
+    desc = b.create<LLVM::InsertValueOp>(desc, adaptor.step(),
+                                         rewriter.getI64ArrayAttr(2));
     rewriter.replaceOp(rangeOp, desc);
     return success();
   }
 };
 
 // ReshapeOp creates a new view descriptor of the proper rank.
 // For now, the only conversion supported is for target MemRef with static sizes
 // and strides.
matchAndRewrite(ReshapeOp reshapeOp, ArrayRef<Value> operands,
     int64_t offset;
     SmallVector<int64_t, 4> strides;
     auto res = getStridesAndOffset(dstType, strides, offset);
     if (failed(res) || llvm::any_of(strides, [](int64_t val) {
           return ShapedType::isDynamicStrideOrOffset(val);
         }))
       return failure();
 
-    edsc::ScopedContext context(rewriter, reshapeOp->getLoc());
     ReshapeOpAdaptor adaptor(operands);
-    BaseViewConversionHelper baseDesc(adaptor.src());
-    BaseViewConversionHelper desc(typeConverter->convertType(dstType));
-    desc.setAllocatedPtr(baseDesc.allocatedPtr());
-    desc.setAlignedPtr(baseDesc.alignedPtr());
-    desc.setOffset(baseDesc.offset());
+    MemRefDescriptor baseDesc(adaptor.src());
+    Location loc = reshapeOp->getLoc();
+    auto desc = MemRefDescriptor::undef(rewriter, reshapeOp->getLoc(),
+                                        typeConverter->convertType(dstType));
+    desc.setAllocatedPtr(rewriter, loc, baseDesc.allocatedPtr(rewriter, loc));
+    desc.setAlignedPtr(rewriter, loc, baseDesc.alignedPtr(rewriter, loc));
+    desc.setOffset(rewriter, loc, baseDesc.offset(rewriter, loc));
     for (auto en : llvm::enumerate(dstType.getShape()))
-      desc.setConstantSize(en.index(), en.value());
+      desc.setConstantSize(rewriter, loc, en.index(), en.value());
     for (auto en : llvm::enumerate(strides))
-      desc.setConstantStride(en.index(), en.value());
+      desc.setConstantStride(rewriter, loc, en.index(), en.value());
     rewriter.replaceOp(reshapeOp, {desc});
     return success();
   }
 };
 
 // YieldOp produces and LLVM::ReturnOp.
 class YieldOpConversion : public ConvertOpToLLVMPattern<linalg::YieldOp> {
 public:

mlir/lib/Conversion/LinalgToStandard/CMakeLists.txt

 add_mlir_conversion_library(MLIRLinalgToStandard
   LinalgToStandard.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/LinalgToStandard
 
   DEPENDS
   MLIRConversionPassIncGen
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
-  MLIREDSC
   MLIRIR
   MLIRLinalg
   MLIRMemRef
   MLIRPass
   MLIRSCF
   MLIRTransforms
   )

mlir/lib/Conversion/ShapeToStandard/CMakeLists.txt

add_mlir_conversion_library(MLIRShapeToStandard
   DEPENDS
   MLIRConversionPassIncGen
   ShapeToStandardIncGen
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
-  MLIREDSC
   MLIRIR
   MLIRMemRef
   MLIRShape
   MLIRTensor
   MLIRPass
   MLIRSCF
   MLIRTransforms
   )

mlir/lib/Conversion/VectorToSCF/CMakeLists.txt

 add_mlir_conversion_library(MLIRVectorToSCF
   VectorToSCF.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToSCF
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
-  MLIREDSC
   MLIRLLVMIR
   MLIRMemRef
   MLIRTransforms
   )

mlir/lib/Dialect/Affine/IR/CMakeLists.txt

 add_mlir_dialect_library(MLIRAffine
   AffineMemoryOpInterfaces.cpp
   AffineOps.cpp
   AffineValueMap.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine
 
   DEPENDS
   MLIRAffineMemoryOpInterfacesIncGen
   MLIRAffineOpsIncGen
 
   LINK_LIBS PUBLIC
-  MLIREDSC
   MLIRIR
   MLIRLoopLikeInterface
   MLIRMemRef
   MLIRSideEffectInterfaces
   MLIRStandard
   )

mlir/lib/Dialect/Affine/Transforms/CMakeLists.txt

add_mlir_dialect_library(MLIRAffineTransforms
   DEPENDS
   MLIRAffineOpsIncGen
   MLIRAffinePassIncGen
   MLIRLoopLikeInterfaceIncGen
 
   LINK_LIBS PUBLIC
   MLIRAffine
   MLIRAffineUtils
-  MLIREDSC
   MLIRIR
   MLIRMemRef
   MLIRPass
   MLIRSideEffectInterfaces
   MLIRStandard
   MLIRTransformUtils
   MLIRVector
   MLIRVectorToLLVM
   )
 

mlir/lib/Dialect/GPU/CMakeLists.txt

add_mlir_dialect_library(MLIRGPU
   MLIRGPUPassIncGen
   MLIRParallelLoopMapperAttrGen
   MLIRParallelLoopMapperEnumsGen
 
   LINK_LIBS PUBLIC
   MLIRAsync
   MLIRDataLayoutInterfaces
   MLIRDLTI
-  MLIREDSC
   MLIRIR
   MLIRMemRef
   MLIRLLVMIR
   MLIRLLVMToLLVMIRTranslation
   MLIRSCF
   MLIRPass
   MLIRSideEffectInterfaces
   MLIRStandard

mlir/lib/Dialect/GPU/Transforms/MemoryPromotion.cpp

 //===- MemoryPromotion.cpp - Utilities for moving data across GPU memories ===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements utilities that allow one to create IR moving the data
 // across different levels of the GPU memory hierarchy.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/GPU/MemoryPromotion.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/SCF.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/LoopUtils.h"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::gpu;
 
 /// Returns the textual name of a GPU dimension.
 static StringRef getDimName(unsigned dim) {
   if (dim == 0)
     return "x";
   if (dim == 1)
     return "y";

mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp

 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "linalg-drop-unit-dims"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 
 /// Implements a pass that canonicalizes the uses of unit-extent dimensions for
 /// broadcasting. For example,
 ///
 /// ```mlir
 /// #accesses = [
 ///   affine_map<(d0, d1) -> (0, d1)>,

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #include <set>
 
 #define DEBUG_TYPE "linalg-fusion"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 
 using llvm::dbgs;
 
 /// Implements a simple high-level fusion pass on linalg structured operations.
 ///
 /// In each block, linalg ops are processed in reverse textual order.
 /// Given a linalg op `O`, fusion occurs by:
mlir::linalg::fuseProducerOfBuffer(OpBuilder &b, OpOperand &consumerOpOperand,
   if (!subView) {
     LLVM_DEBUG(llvm::dbgs() << "\nNot fusable (not a subview)");
     return llvm::None;
   }
 
   // Fuse `producer` just before `consumer`.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(consumerOpOperand.getOwner());
-  ScopedContext scope(b, consumerOpOperand.getOwner()->getLoc());
   LLVM_DEBUG(llvm::dbgs() << "Fuse into consumer: "
                           << *consumerOpOperand.getOwner() << "\n");
 
   auto fusedProducer = fuse(b, producerOp, *producerMap, consumerOpOperand);
   return FusionInfo{producerOp, fusedProducer};
 }
 
 /// Walk back use-def chain through scf::For yields.
mlir::linalg::fuseProducerOfTensor(OpBuilder &b, OpResult producerOpResult,
   // If producer is already in the same block as consumer, we are done.
   if (consumerOpOperand.get().getParentBlock() ==
       producerOpResult.getParentBlock())
     return {};
 
   // Insert fused `producer` just before `consumer`.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(consumerOp);
-  ScopedContext scope(b, consumerOp->getLoc());
   LLVM_DEBUG(llvm::dbgs() << "Fuse into consumer: " << *consumerOp << "\n");
   LinalgOp fusedProducer =
       fuse(b, producerOp,
            producerOp.getOutputIndexingMap(producerOpResult.getResultNumber()),
            consumerOpOperand);
 
   // Replace use.
   // Canonicalizations are not guaranteed to have happened before constructing
tileAndFuseLinalgOpsImpl(OpBuilder &b, ArrayRef<LinalgOp> ops,
   // better fusion.
   if (!tilingOptions.interchangeVector.empty()) {
     rootOp.emitRemark("unable to handle tile and fuse with interchange");
     return llvm::None;
   }
 
   OpBuilder::InsertionGuard guard(b);
   b.setInsertionPoint(rootOp);
-  ScopedContext scope(b, rootOp.getLoc());
 
   // Find all the producers.
   LLVM_DEBUG(llvm::dbgs() << "findAllFusableDependences\n");
   FusableOpDependencesTy fusableDependences =
       findAllFusableDependences(ops, dependenceGraph);
   if (fusableDependences.empty()) {
     LLVM_DEBUG(llvm::dbgs() << "no fusable dependencies found\n");
     return llvm::None;

mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp

 // Linalg ops to linalg.generic ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
-#include "mlir/EDSC/Builders.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"

mlir/lib/Dialect/Linalg/Transforms/Interchange.cpp

 //===- Interchange.cpp - Linalg interchange transformation ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg interchange transformation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/Support/Debug.h"

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 #include "llvm/Support/CommandLine.h"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::scf;
 
 #define DEBUG_TYPE "linalg-tiling"
 
 static bool isZero(Value v) {
   if (auto cst = v.getDefiningOp<ConstantIndexOp>())
     return cst.getValue() == 0;
return TiledLinalgOp{
       res, loops, outermostLoop ? outermostLoop->getResults() : tensorResults};
 }
 
 template <typename LoopTy>
 Optional<TiledLinalgOp> static tileLinalgOpImpl(
     OpBuilder &b, LinalgOp op, const LinalgTilingOptions &options) {
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(op);
-  ScopedContext scope(b, op.getLoc());
 
   if (!options.tileSizeComputationFunction)
     return llvm::None;
 
   // Enforce the convention that "tiling by zero" skips tiling a particular
   // dimension. This convention is significantly simpler to handle instead of
   // adjusting affine maps to account for missing dimensions.
   auto nLoops = op.getNumLoops();

mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <type_traits>
 
 #define DEBUG_TYPE "linalg-transforms"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 
 #define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE << "]: ")
 
 //===----------------------------------------------------------------------===//
 // Transformations exposed as rewrite patterns.
 //===----------------------------------------------------------------------===//
 // Marker used as attribute name in generated Linalg rewriting transformations.

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <type_traits>
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 
 using llvm::dbgs;
 
 #define DEBUG_TYPE "linalg-vectorization"
 
 /// Return the unique instance of OpType in `block` if it is indeed unique.
 /// Return null if none or more than 1 instances exist.

 }
 
 LogicalResult
 mlir::linalg::vectorizeLinalgOp(OpBuilder &b, Operation *op,
                                 SmallVectorImpl<Value> &newResults) {
   if (failed(vectorizeLinalgOpPrecondition(op)))
     return failure();
 
-  edsc::ScopedContext scope(b, op->getLoc());
   auto linalgOp = cast<LinalgOp>(op);
-
   if (isaContractionOpInterface(linalgOp))
     return vectorizeContraction(b, linalgOp, newResults);
 
   LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE "]: "
                     << "Vectorize linalg op as a generic by broadcasting to "
                        "maximal common shape: "
                     << *op);
   return vectorizeAsLinalgGeneric(b, linalgOp, newResults,

 }
 
 // TODO: cleanup all the convolution vectorization patterns.
 template <class ConvOp, int N>
 LogicalResult ConvOpVectorization<ConvOp, N>::matchAndRewrite(
     ConvOp op, PatternRewriter &rewriter) const {
   Location loc = op.getLoc();
   MLIRContext *context = op.getContext();
-  edsc::ScopedContext scope(rewriter, loc);
 
   ShapedType inShapeType = op.getInputShapedType(0);
   ShapedType kShapeType = op.getInputShapedType(1);
 
   ArrayRef<int64_t> inShape = inShapeType.getShape();
   ArrayRef<int64_t> kShape = kShapeType.getShape();
 
   if (!inShapeType.hasStaticShape() || !kShapeType.hasStaticShape())

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/SCF/SCF.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/StandardOps/Utils/Utils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/LoopUtils.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "linalg-utils"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::scf;
 
 static bool isZero(Value v) {
   if (auto cst = v.getDefiningOp<ConstantIndexOp>())
     return cst.getValue() == 0;
   return false;
 }
void GenerateLoopNest<scf::ParallelOp>::doit(
 
   // Get the loop lb, ub, and step.
   unpackRanges(loopRanges, lbsStorage, ubsStorage, stepsStorage);
 
   // Modify the lb, ub, and step based on the distribution options.
   SmallVector<DistributionMethod, 0> distributionMethod;
   if (distributionOptions) {
     auto &options = distributionOptions.getValue();
-    OpBuilder &b = edsc::ScopedContext::getBuilderRef();
-    Location loc = edsc::ScopedContext::getLocation();
     distributionMethod.assign(distributionOptions->distributionMethod.begin(),
                               distributionOptions->distributionMethod.end());
     SmallVector<Range, 2> parallelLoopRanges;
     for (auto iteratorType : enumerate(iteratorTypes)) {
       if (isParallelIteratorType(iteratorType.value()))
         parallelLoopRanges.push_back(loopRanges[iteratorType.index()]);
     }
     if (distributionMethod.size() < parallelLoopRanges.size())

mlir/lib/Dialect/StandardOps/CMakeLists.txt

 add_mlir_dialect_library(MLIRStandard
   IR/Ops.cpp
-  EDSC/Builders.cpp
-  EDSC/Intrinsics.cpp
   Utils/Utils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/StandardOps
 
   DEPENDS
   MLIRStandardOpsIncGen
 
   LINK_LIBS PUBLIC
   MLIRCallInterfaces
   MLIRCastInterfaces
   MLIRControlFlowInterfaces
-  MLIREDSC
   MLIRIR
   MLIRSideEffectInterfaces
   MLIRTensor
   MLIRVectorInterfaces
   MLIRViewLikeInterface
   )
 
 add_subdirectory(Transforms)

mlir/lib/Dialect/StandardOps/EDSC/Builders.cpp

-//===- Builders.cpp - MLIR Declarative Builder Classes --------------------===//
-//
-// 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/Dialect/StandardOps/EDSC/Intrinsics.h"
-#include "mlir/IR/AffineExpr.h"
-#include "mlir/IR/AffineMap.h"
-
-using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
-
-mlir::edsc::VectorBoundsCapture::VectorBoundsCapture(VectorType t) {
-  for (auto s : t.getShape()) {
-    lbs.push_back(std_constant_index(0));
-    ubs.push_back(std_constant_index(s));
-    steps.push_back(1);
-  }
-}
-
-mlir::edsc::VectorBoundsCapture::VectorBoundsCapture(Value v)
-    : VectorBoundsCapture(v.getType().cast<VectorType>()) {}

mlir/lib/Dialect/StandardOps/EDSC/Intrinsics.cpp

-//===- Intrinsics.cpp - MLIR Operations for Declarative Builders ----------===//
-//
-// 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/Dialect/StandardOps/EDSC/Intrinsics.h"
-#include "mlir/IR/AffineExpr.h"
-
-using namespace mlir;
-using namespace mlir::edsc;
-
-BranchOp mlir::edsc::intrinsics::std_br(Block *block, ValueRange operands) {
-  return OperationBuilder<BranchOp>(block, operands);
-}
-
-CondBranchOp mlir::edsc::intrinsics::std_cond_br(Value cond, Block *trueBranch,
-                                                 ValueRange trueOperands,
-                                                 Block *falseBranch,
-                                                 ValueRange falseOperands) {
-  return OperationBuilder<CondBranchOp>(cond, trueBranch, trueOperands,
-                                        falseBranch, falseOperands);
-}

mlir/lib/EDSC/Builders.cpp

-//===- Builders.cpp - MLIR Declarative Builder Classes --------------------===//
-//
-// 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/EDSC/Builders.h"
-#include "mlir/IR/AffineExpr.h"
-#include "mlir/IR/AffineMap.h"
-
-#include "llvm/ADT/Optional.h"
-
-using namespace mlir;
-using namespace mlir::edsc;
-
-mlir::edsc::ScopedContext::ScopedContext(OpBuilder &b)
-    : ScopedContext(b, b.getInsertionPoint()->getLoc()) {}
-
-mlir::edsc::ScopedContext::ScopedContext(OpBuilder &b, Location location)
-    : builder(b), guard(builder), location(location),
-      enclosingScopedContext(ScopedContext::getCurrentScopedContext()) {
-  getCurrentScopedContext() = this;
-}
-
-/// Sets the insertion point of the builder to 'newInsertPt' for the duration
-/// of the scope. The existing insertion point of the builder is restored on
-/// destruction.
-mlir::edsc::ScopedContext::ScopedContext(OpBuilder &b,
-                                         OpBuilder::InsertPoint newInsertPt,
-                                         Location location)
-    : builder(b), guard(builder), location(location),
-      enclosingScopedContext(ScopedContext::getCurrentScopedContext()) {
-  getCurrentScopedContext() = this;
-  builder.restoreInsertionPoint(newInsertPt);
-}
-
-mlir::edsc::ScopedContext::~ScopedContext() {
-  getCurrentScopedContext() = enclosingScopedContext;
-}
-
-ScopedContext *&mlir::edsc::ScopedContext::getCurrentScopedContext() {
-  thread_local ScopedContext *context = nullptr;
-  return context;
-}
-
-OpBuilder &mlir::edsc::ScopedContext::getBuilderRef() {
-  assert(ScopedContext::getCurrentScopedContext() &&
-         "Unexpected Null ScopedContext");
-  return ScopedContext::getCurrentScopedContext()->builder;
-}
-
-Location mlir::edsc::ScopedContext::getLocation() {
-  assert(ScopedContext::getCurrentScopedContext() &&
-         "Unexpected Null ScopedContext");
-  return ScopedContext::getCurrentScopedContext()->location;
-}
-
-MLIRContext *mlir::edsc::ScopedContext::getContext() {
-  return getBuilderRef().getContext();
-}
-
-Block *mlir::edsc::createBlock(TypeRange argTypes) {
-  assert(ScopedContext::getContext() != nullptr && "ScopedContext not set up");
-  OpBuilder &builder = ScopedContext::getBuilderRef();
-  Block *block = builder.getInsertionBlock();
-  assert(block != nullptr &&
-         "insertion point not set up in the builder within ScopedContext");
-
-  return createBlockInRegion(*block->getParent(), argTypes);
-}
-
-Block *mlir::edsc::createBlockInRegion(Region &region, TypeRange argTypes) {
-  assert(ScopedContext::getContext() != nullptr && "ScopedContext not set up");
-  OpBuilder &builder = ScopedContext::getBuilderRef();
-
-  OpBuilder::InsertionGuard guard(builder);
-  return builder.createBlock(&region, {}, argTypes);
-}
-
-void mlir::edsc::appendToBlock(Block *block,
-                               function_ref<void(ValueRange)> builderFn) {
-  assert(ScopedContext::getContext() != nullptr && "ScopedContext not set up");
-  OpBuilder &builder = ScopedContext::getBuilderRef();
-
-  OpBuilder::InsertionGuard guard(builder);
-  if (block->empty() || !block->back().mightHaveTrait<OpTrait::IsTerminator>())
-    builder.setInsertionPointToEnd(block);
-  else
-    builder.setInsertionPoint(&block->back());
-  builderFn(block->getArguments());
-}
-
-Block *mlir::edsc::buildInNewBlock(TypeRange argTypes,
-                                   function_ref<void(ValueRange)> builderFn) {
-  assert(ScopedContext::getContext() != nullptr && "ScopedContext not set up");
-  OpBuilder &builder = ScopedContext::getBuilderRef();
-  Block *block = builder.getInsertionBlock();
-  assert(block != nullptr &&
-         "insertion point not set up in the builder within ScopedContext");
-  return buildInNewBlock(*block->getParent(), argTypes, builderFn);
-}
-
-Block *mlir::edsc::buildInNewBlock(Region &region, TypeRange argTypes,
-                                   function_ref<void(ValueRange)> builderFn) {
-  assert(ScopedContext::getContext() != nullptr && "ScopedContext not set up");
-  OpBuilder &builder = ScopedContext::getBuilderRef();
-
-  Block *block = createBlockInRegion(region, argTypes);
-  OpBuilder::InsertionGuard guard(builder);
-  builder.setInsertionPointToStart(block);
-  builderFn(block->getArguments());
-  return block;
-}
-

mlir/lib/EDSC/CMakeLists.txt

-set(LLVM_OPTIONAL_SOURCES
-  Builders.cpp
-  CoreAPIs.cpp
-  )
-
-add_mlir_library(MLIREDSC
-  Builders.cpp
-
-  ADDITIONAL_HEADER_DIRS
-  ${MLIR_MAIN_INCLUDE_DIR}/mlir/EDSC
-
-  LINK_LIBS PUBLIC
-  MLIRIR
-  MLIRSupport
-  )
-

mlir/tools/mlir-cpu-runner/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
   Support
   nativecodegen
   native
   )
 
 add_llvm_tool(mlir-cpu-runner
   mlir-cpu-runner.cpp
   )
 llvm_update_compile_flags(mlir-cpu-runner)
 target_link_libraries(mlir-cpu-runner PRIVATE
   MLIRAnalysis
-  MLIREDSC
   MLIRExecutionEngine
   MLIRIR
   MLIRJitRunner
   MLIRLLVMIR
   MLIRLLVMToLLVMIRTranslation
   MLIRToLLVMIRTranslationRegistration
   MLIRParser
   MLIRTargetLLVMIRExport
   MLIRSupport
   )

mlir/tools/mlir-lsp-server/CMakeLists.txt

 
 set(LIBS
   ${dialect_libs}
   ${conversion_libs}
   ${test_libs}
   MLIRLoopAnalysis
   MLIRAnalysis
   MLIRDialect
-  MLIREDSC
   MLIRLspServerLib
   MLIRParser
   MLIRPass
   MLIRTransforms
   MLIRTransformUtils
   MLIRSupport
   MLIRIR
   )

mlir/tools/mlir-opt/CMakeLists.txt

 
 set(LIBS
   ${dialect_libs}
   ${conversion_libs}
   ${test_libs}
   MLIRLoopAnalysis
   MLIRAnalysis
   MLIRDialect
-  MLIREDSC
   MLIROptLib
   MLIRParser
   MLIRPass
   MLIRTransforms
   MLIRTransformUtils
   MLIRSupport
   MLIRIR
   )

mlir/tools/mlir-reduce/CMakeLists.txt

 endif()
 
 set(LIBS
   ${dialect_libs}
   ${conversion_libs}
   ${test_libs}
   MLIRAnalysis
   MLIRDialect
-  MLIREDSC
   MLIRIR
   MLIRLoopAnalysis
   MLIROptLib
   MLIRParser
   MLIRPass
   MLIRReduce
   MLIRSupport
   MLIRTransforms

mlir/tools/mlir-spirv-cpu-runner/CMakeLists.txt

if (MLIR_SPIRV_CPU_RUNNER_ENABLED)
 
   llvm_update_compile_flags(mlir-spirv-cpu-runner)
 
   get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
 
   target_link_libraries(mlir-spirv-cpu-runner PRIVATE
     ${conversion_libs}
     MLIRAnalysis
-    MLIREDSC
     MLIRExecutionEngine
     MLIRGPU
     MLIRIR
     MLIRJitRunner
     MLIRLLVMIR
     MLIRLLVMToLLVMIRTranslation
     MLIRMemRef
     MLIRParser
     MLIRSPIRV
     MLIRStandard
     MLIRTargetLLVMIRExport
     MLIRTransforms
     MLIRTranslation
     MLIRSupport
   )
 endif()

mlir/tools/mlir-vulkan-runner/CMakeLists.txt

target_link_libraries(vulkan-runtime-wrappers
     PUBLIC
     ${Vulkan_LIBRARY}
   )
 
   get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
   set(LIBS
     ${conversion_libs}
     MLIRAnalysis
-    MLIREDSC
     MLIRExecutionEngine
     MLIRGPU
     MLIRIR
     MLIRJitRunner
     MLIRLLVMIR
     MLIRLLVMToLLVMIRTranslation
     MLIRMemRef
     MLIRParser