[Utils] Remove unused utils (nod-ai#801)

compiler/plugins/target/AMD-AIE/aie/CMakeLists.txt

@@ -145,7 +145,6 @@ iree_cc_library(
     ::AIEDialectIR
     ::AIEXDialectIR
     ::AIENormalizeAddressSpacesGen
-    iree::target::amd-aie::Utils::Utils
 )
 
 add_subdirectory(test)

compiler/plugins/target/AMD-AIE/iree-amd-aie/CMakeLists.txt

@@ -39,7 +39,6 @@ iree_compiler_register_plugin(
 add_subdirectory(IR)
 add_subdirectory(Target)
 add_subdirectory(Transforms)
-add_subdirectory(Utils)
 add_subdirectory(Test/samples)
 add_subdirectory(Test/OPT/failing_tests)
 add_subdirectory(Test/transform_dialect)

compiler/plugins/target/AMD-AIE/iree-amd-aie/IR/AMDAIEDmaOpInterface.cpp

@@ -9,7 +9,6 @@
 #include "iree-amd-aie/IR/AMDAIEDmaOpInterface.h"
 
 #include "iree-amd-aie/IR/AMDAIEAttrs.h"
-#include "iree-amd-aie/Utils/Utils.h"
 
 /// Include the definitions of the dma-like interfaces.
 #include "iree-amd-aie/IR/AMDAIEDmaOpInterface.cpp.inc"
@@ -49,35 +48,6 @@ std::optional<int64_t> getStaticBaseOffset(DoublyStridedOpInterface op) {
   return baseOffset;
 }
 
-/// Utility to compute the static extent on either the source or target side
-/// of a doubly strided operation. The extent is the range of elements covered
-/// by the strided access pattern, starting from the base offset.
-///
-/// Returns std::nullopt if the extent can't be computed due to for example
-/// dynamic strides or sizes.
-///
-/// Returns 0 in case of empty offsets/strides/sizes, which represents a
-/// contiguous access of all values operated on.
-template <CopyOpOperateOn OperateOn>
-std::optional<int64_t> getStaticExtent(DoublyStridedOpInterface op) {
-  SmallVector<OpFoldResult> sizes;
-  SmallVector<OpFoldResult> strides;
-  if constexpr (OperateOn == CopyOpOperateOn::Source) {
-    sizes = op.getSourceMixedSizes();
-    strides = op.getSourceMixedStrides();
-  } else if constexpr (OperateOn == CopyOpOperateOn::Target) {
-    sizes = op.getTargetMixedSizes();
-    strides = op.getTargetMixedStrides();
-  } else {
-    assert(false && "Function can only operate on Source or Target");
-  }
-  std::optional<SmallVector<int64_t>> staticSizes = getConstantIntValues(sizes);
-  std::optional<SmallVector<int64_t>> staticStrides =
-      getConstantIntValues(strides);
-  if (!staticSizes || !staticStrides) return std::nullopt;
-  return getAccessRangeExtent(staticSizes.value(), staticStrides.value());
-}
-
 template <CopyOpOperateOn OperateOn>
 std::optional<int64_t> getStaticSize(DoublyStridedOpInterface op) {
   SmallVector<OpFoldResult> sizes;
@@ -101,11 +71,6 @@ std::optional<int64_t> getSourceStaticBaseOffset(DoublyStridedOpInterface op) {
   return getStaticBaseOffset<CopyOpOperateOn::Source>(op);
 }
 
-/// Return the static access extent on the source side if it can be computed.
-/// Otherwise, returns nullopt.
-std::optional<int64_t> getSourceStaticExtent(DoublyStridedOpInterface op) {
-  return getStaticExtent<CopyOpOperateOn::Source>(op);
-}
 
 std::optional<int64_t> getSourceStaticSize(DoublyStridedOpInterface op) {
   return getStaticSize<CopyOpOperateOn::Source>(op);
@@ -117,11 +82,6 @@ std::optional<int64_t> getTargetStaticBaseOffset(DoublyStridedOpInterface op) {
   return getStaticBaseOffset<CopyOpOperateOn::Target>(op);
 }
 
-/// Return the static access extent on the target side if it can be computed.
-/// Otherwise, returns nullopt.
-std::optional<int64_t> getTargetStaticExtent(DoublyStridedOpInterface op) {
-  return getStaticExtent<CopyOpOperateOn::Target>(op);
-}
 
 std::optional<int64_t> getTargetStaticSize(DoublyStridedOpInterface op) {
   return getStaticSize<CopyOpOperateOn::Target>(op);

compiler/plugins/target/AMD-AIE/iree-amd-aie/IR/AMDAIEDmaOpInterface.h

@@ -24,9 +24,6 @@ namespace detail {
 /// Otherwise, returns nullopt.
 std::optional<int64_t> getSourceStaticBaseOffset(DoublyStridedOpInterface op);
 
-/// Return the static access extent on the source side if it can be computed.
-/// Otherwise, returns nullopt.
-std::optional<int64_t> getSourceStaticExtent(DoublyStridedOpInterface op);
 
 /// Return the static size of the access on the source side if it can be
 /// computed. Otherwise, returns nullopt.
@@ -36,10 +33,6 @@ std::optional<int64_t> getSourceStaticSize(DoublyStridedOpInterface op);
 /// Otherwise, returns nullopt.
 std::optional<int64_t> getTargetStaticBaseOffset(DoublyStridedOpInterface op);
 
-/// Return the static access extent on the target side if it can be computed.
-/// Otherwise, returns nullopt.
-std::optional<int64_t> getTargetStaticExtent(DoublyStridedOpInterface op);
-
 /// Return the static size of the access on the target side if it can be
 /// computed. Otherwise, returns nullopt.
 std::optional<int64_t> getTargetStaticSize(DoublyStridedOpInterface op);

compiler/plugins/target/AMD-AIE/iree-amd-aie/IR/AMDAIEDmaOpInterface.td

@@ -163,27 +163,6 @@ def DoublyStridedOpInterface : OpInterface<"DoublyStridedOpInterface"> {
           ::mlir::cast<DoublyStridedOpInterface>($_op.getOperation()));
       }]
     >,
-    InterfaceMethod<
-      /*desc=*/[{
-        Return the static access range extent on the target side if it can be
-        computed. Otherwise, returns nullopt.
-
-        The extent is the number of elements in the range of elements being
-        accessed. This is the same as the last relative index (with regard to
-        base offset) being accessed + 1.
-
-        A return value of 0 is the result of empty offsets/strides/sizes and
-        represents a contiguous access of all values operated on.
-      }],
-      /*retTy=*/"std::optional<int64_t>",
-      /*methodName=*/"getTargetStaticExtent",
-      /*args=*/(ins),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        return detail::getTargetStaticExtent(
-          ::mlir::cast<DoublyStridedOpInterface>($_op.getOperation()));
-      }]
-    >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static size of the access on the target side if it can be
@@ -314,27 +293,6 @@ def DoublyStridedOpInterface : OpInterface<"DoublyStridedOpInterface"> {
           ::mlir::cast<DoublyStridedOpInterface>($_op.getOperation()));
       }]
     >,
-    InterfaceMethod<
-      /*desc=*/[{
-        Return the static access range extent on the source side if it can be
-        computed. Otherwise, returns nullopt.
-
-        The extent is the number of elements in the range of elements being
-        accessed. This is the same as the last relative index (with regard to
-        base offset) being accessed + 1.
-
-        A return value of 0 is the result of empty offsets/strides/sizes and
-        represents a contiguous access of all values operated on.
-      }],
-      /*retTy=*/"std::optional<int64_t>",
-      /*methodName=*/"getSourceStaticExtent",
-      /*args=*/(ins),
-      /*methodBody=*/"",
-      /*defaultImplementation=*/[{
-        return detail::getSourceStaticExtent(
-          ::mlir::cast<DoublyStridedOpInterface>($_op.getOperation()));
-      }]
-    >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static size of the access on the source side if it can be

compiler/plugins/target/AMD-AIE/iree-amd-aie/IR/CMakeLists.txt

@@ -48,7 +48,6 @@ iree_cc_library(
     ::AMDAIETypesGen
     ::AMDAIEAttrsGen
     iree-amd-aie::aie_runtime::AMDAIEEnums
-    iree::target::amd-aie::Utils::Utils
     LLVMSupport
     MLIRArithUtils
     MLIRCopyOpInterface