huge refactor for high RewritePatterns usage and less ad-hoc cpp code

remove Spatial many ops in favor of tensor ops like in pim
2026-05-12 10:35:44 +02:00
parent feaff820e1
commit 909c4acfdd
84 changed files with 4048 additions and 3310 deletions
@@ -72,9 +72,8 @@ inline ParseResult parseCompressedRepeatedList(OpAsmParser& parser,
 }

 template <typename IntT>
-inline ParseResult parseCompressedIntegerEntries(OpAsmParser& parser,
-                                                 ListDelimiter delimiter,
-                                                 SmallVectorImpl<IntT>& values) {
+inline ParseResult
+parseCompressedIntegerEntries(OpAsmParser& parser, ListDelimiter delimiter, SmallVectorImpl<IntT>& values) {
  if (succeeded(parseOptionalCloseDelimiter(parser, delimiter)))
    return success();

@@ -113,8 +112,8 @@ inline ParseResult parseCompressedIntegerEntries(OpAsmParser& parser,
            return parser.emitError(parser.getCurrentLocation(), "repeat count after 'x' must be positive");
        }
        if ((last - first) % step != 0) {
-          return parser.emitError(
-            parser.getCurrentLocation(), "range end must be reachable from start using the given step");
+          return parser.emitError(parser.getCurrentLocation(),
+                                  "range end must be reachable from start using the given step");
        }

        for (int64_t value = first; value <= last; value += step)
@@ -140,9 +139,8 @@ inline ParseResult parseCompressedIntegerEntries(OpAsmParser& parser,
 }

 template <typename IntT>
-inline ParseResult parseCompressedIntegerSequence(OpAsmParser& parser,
-                                                  ListDelimiter delimiter,
-                                                  SmallVectorImpl<IntT>& values) {
+inline ParseResult
+parseCompressedIntegerSequence(OpAsmParser& parser, ListDelimiter delimiter, SmallVectorImpl<IntT>& values) {
  if (parseOpenDelimiter(parser, delimiter))
    return failure();
  return parseCompressedIntegerEntries(parser, delimiter, values);
@@ -166,9 +164,7 @@ inline void printCompressedEqualRuns(OpAsmPrinter& printer, RangeT entries, Prin
 }

 template <typename IntT>
-inline void printCompressedIntegerSequence(OpAsmPrinter& printer,
-                                           ArrayRef<IntT> values,
-                                           ListDelimiter delimiter) {
+inline void printCompressedIntegerSequence(OpAsmPrinter& printer, ArrayRef<IntT> values, ListDelimiter delimiter) {
  struct FlatCompression {
    enum class Kind {
      Single,
@@ -388,9 +384,7 @@ inline void printCompressedTypeList(OpAsmPrinter& printer, TypeRange types, List
  printCloseDelimiter(printer, delimiter);
 }

-inline ParseResult parseCompressedTypeSequence(OpAsmParser& parser,
-                                               SmallVectorImpl<Type>& types,
-                                               bool allowEmpty) {
+inline ParseResult parseCompressedTypeSequence(OpAsmParser& parser, SmallVectorImpl<Type>& types, bool allowEmpty) {
  Type firstType;
  OptionalParseResult firstTypeResult = parser.parseOptionalType(firstType);
  if (!firstTypeResult.has_value()) {
@@ -422,10 +416,9 @@ inline ParseResult parseCompressedTypeSequence(OpAsmParser& parser,
  return success();
 }

-inline ParseResult parseCompressedOperandEntryWithFirst(
-  OpAsmParser& parser,
-  OpAsmParser::UnresolvedOperand firstOperand,
-  SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
+inline ParseResult parseCompressedOperandEntryWithFirst(OpAsmParser& parser,
+                                                        OpAsmParser::UnresolvedOperand firstOperand,
+                                                        SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
  if (succeeded(parser.parseOptionalKeyword("to"))) {
    OpAsmParser::UnresolvedOperand lastOperand;
    if (parser.parseOperand(lastOperand))
@@ -447,9 +440,8 @@ inline ParseResult parseCompressedOperandEntryWithFirst(
  return success();
 }

-inline ParseResult parseOneCompressedOperandEntry(
-  OpAsmParser& parser,
-  SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
+inline ParseResult parseOneCompressedOperandEntry(OpAsmParser& parser,
+                                                  SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
  OpAsmParser::UnresolvedOperand firstOperand;
  if (parser.parseOperand(firstOperand))
    return failure();
@@ -474,9 +466,8 @@ inline ParseResult parseCompressedOperandList(OpAsmParser& parser,
  }
 }

-inline ParseResult parseCompressedOperandSequence(
-  OpAsmParser& parser,
-  SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
+inline ParseResult parseCompressedOperandSequence(OpAsmParser& parser,
+                                                  SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
  if (parseOneCompressedOperandEntry(parser, operands))
    return failure();
  while (succeeded(parser.parseOptionalComma()))
@@ -485,9 +476,7 @@ inline ParseResult parseCompressedOperandSequence(
  return success();
 }

-inline ParseResult parseCompressedTypeList(OpAsmParser& parser,
-                                           ListDelimiter delimiter,
-                                           SmallVectorImpl<Type>& types) {
+inline ParseResult parseCompressedTypeList(OpAsmParser& parser, ListDelimiter delimiter, SmallVectorImpl<Type>& types) {
  if (parseOpenDelimiter(parser, delimiter))
    return failure();
  if (succeeded(parseOptionalCloseDelimiter(parser, delimiter)))
@@ -522,10 +511,7 @@ inline bool hasRepeatedTuple(TypeRange types, size_t tupleSize) {
  return true;
 }

-inline void printValueTupleRun(OpAsmPrinter& printer,
-                               ValueRange values,
-                               size_t tupleSize,
-                               ListDelimiter delimiter) {
+inline void printValueTupleRun(OpAsmPrinter& printer, ValueRange values, size_t tupleSize, ListDelimiter delimiter) {
  printOpenDelimiter(printer, delimiter);
  printOpenDelimiter(printer, ListDelimiter::Paren);
  for (size_t index = 0; index < tupleSize; ++index) {
@@ -538,10 +524,7 @@ inline void printValueTupleRun(OpAsmPrinter& printer,
  printCloseDelimiter(printer, delimiter);
 }

-inline void printTypeTupleRun(OpAsmPrinter& printer,
-                              TypeRange types,
-                              size_t tupleSize,
-                              ListDelimiter delimiter) {
+inline void printTypeTupleRun(OpAsmPrinter& printer, TypeRange types, size_t tupleSize, ListDelimiter delimiter) {
  printOpenDelimiter(printer, delimiter);
  printOpenDelimiter(printer, ListDelimiter::Paren);
  for (size_t index = 0; index < tupleSize; ++index) {
@@ -554,10 +537,9 @@ inline void printTypeTupleRun(OpAsmPrinter& printer,
  printCloseDelimiter(printer, delimiter);
 }

-inline ParseResult parseCompressedOrTupleOperandList(
-  OpAsmParser& parser,
-  ListDelimiter delimiter,
-  SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
+inline ParseResult parseCompressedOrTupleOperandList(OpAsmParser& parser,
+                                                     ListDelimiter delimiter,
+                                                     SmallVectorImpl<OpAsmParser::UnresolvedOperand>& operands) {
  if (parseOpenDelimiter(parser, delimiter))
    return failure();
  if (succeeded(parseOptionalCloseDelimiter(parser, delimiter)))
@@ -604,9 +586,8 @@ inline ParseResult parseCompressedOrTupleOperandList(
  }
 }

-inline ParseResult parseCompressedOrTupleTypeList(OpAsmParser& parser,
-                                                  ListDelimiter delimiter,
-                                                  SmallVectorImpl<Type>& types) {
+inline ParseResult
+parseCompressedOrTupleTypeList(OpAsmParser& parser, ListDelimiter delimiter, SmallVectorImpl<Type>& types) {
  if (parseOpenDelimiter(parser, delimiter))
    return failure();
  if (succeeded(parseOptionalCloseDelimiter(parser, delimiter)))