/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/include/mlir/IR/Attributes.h

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/include/mlir/IR/Attributes.h
Warning:	line 66, column 33 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ArithmeticOps.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D MLIR_CUDA_CONVERSIONS_ENABLED=1 -D MLIR_ROCM_CONVERSIONS_ENABLED=1 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/mlir/lib/Dialect/Arithmetic/IR -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/lib/Dialect/Arithmetic/IR -I include -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/include -I tools/mlir/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-04-20-140412-16051-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

→

1//===- ArithmeticOps.cpp - MLIR Arithmetic dialect ops implementation -----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#include <utility>

11#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
12#include "mlir/Dialect/CommonFolders.h"
13#include "mlir/IR/Builders.h"
14#include "mlir/IR/Matchers.h"
15#include "mlir/IR/OpImplementation.h"
16#include "mlir/IR/PatternMatch.h"
17#include "mlir/IR/TypeUtilities.h"
18#include "llvm/ADT/SmallString.h"

20#include "llvm/ADT/APSInt.h"

22using namespace mlir;
23using namespace mlir::arith;

25//===----------------------------------------------------------------------===//
26// Pattern helpers
27//===----------------------------------------------------------------------===//

29static IntegerAttr addIntegerAttrs(PatternRewriter &builder, Value res,
                                 Attribute lhs, Attribute rhs) {
return builder.getIntegerAttr(res.getType(),
                              lhs.cast<IntegerAttr>().getInt() +
                                  rhs.cast<IntegerAttr>().getInt());
34}

36static IntegerAttr subIntegerAttrs(PatternRewriter &builder, Value res,
                                 Attribute lhs, Attribute rhs) {
return builder.getIntegerAttr(res.getType(),
                              lhs.cast<IntegerAttr>().getInt() -
                                  rhs.cast<IntegerAttr>().getInt());
41}

43/// Invert an integer comparison predicate.
44arith::CmpIPredicate arith::invertPredicate(arith::CmpIPredicate pred) {
switch (pred) {
case arith::CmpIPredicate::eq:
  return arith::CmpIPredicate::ne;
case arith::CmpIPredicate::ne:
  return arith::CmpIPredicate::eq;
case arith::CmpIPredicate::slt:
  return arith::CmpIPredicate::sge;
case arith::CmpIPredicate::sle:
  return arith::CmpIPredicate::sgt;
case arith::CmpIPredicate::sgt:
  return arith::CmpIPredicate::sle;
case arith::CmpIPredicate::sge:
  return arith::CmpIPredicate::slt;
case arith::CmpIPredicate::ult:
  return arith::CmpIPredicate::uge;
case arith::CmpIPredicate::ule:
  return arith::CmpIPredicate::ugt;
case arith::CmpIPredicate::ugt:
  return arith::CmpIPredicate::ule;
case arith::CmpIPredicate::uge:
  return arith::CmpIPredicate::ult;
}
llvm_unreachable("unknown cmpi predicate kind")::llvm::llvm_unreachable_internal("unknown cmpi predicate kind"
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 67);
68}

70static arith::CmpIPredicateAttr invertPredicate(arith::CmpIPredicateAttr pred) {
return arith::CmpIPredicateAttr::get(pred.getContext(),
                                     invertPredicate(pred.getValue()));
73}

75//===----------------------------------------------------------------------===//
76// TableGen'd canonicalization patterns
77//===----------------------------------------------------------------------===//

79namespace {
80#include "ArithmeticCanonicalization.inc"
81} // namespace

83//===----------------------------------------------------------------------===//
84// ConstantOp
85//===----------------------------------------------------------------------===//

87void arith::ConstantOp::getAsmResultNames(
  function_ref<void(Value, StringRef)> setNameFn) {
auto type = getType();
if (auto intCst = getValue().dyn_cast<IntegerAttr>()) {
  auto intType = type.dyn_cast<IntegerType>();

  // Sugar i1 constants with 'true' and 'false'.
  if (intType && intType.getWidth() == 1)
    return setNameFn(getResult(), (intCst.getInt() ? "true" : "false"));

  // Otherwise, build a compex name with the value and type.
  SmallString<32> specialNameBuffer;
  llvm::raw_svector_ostream specialName(specialNameBuffer);
  specialName << 'c' << intCst.getInt();
  if (intType)
    specialName << '_' << type;
  setNameFn(getResult(), specialName.str());
} else {
  setNameFn(getResult(), "cst");
}
107}

109/// TODO: disallow arith.constant to return anything other than signless integer
110/// or float like.
111LogicalResult arith::ConstantOp::verify() {
auto type = getType();
// The value's type must match the return type.
if (getValue().getType() != type) {
  return emitOpError() << "value type " << getValue().getType()
                       << " must match return type: " << type;
}
// Integer values must be signless.
if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
  return emitOpError("integer return type must be signless");
// Any float or elements attribute are acceptable.
if (!getValue().isa<IntegerAttr, FloatAttr, ElementsAttr>()) {
  return emitOpError(
      "value must be an integer, float, or elements attribute");
}
return success();
127}

129bool arith::ConstantOp::isBuildableWith(Attribute value, Type type) {
// The value's type must be the same as the provided type.
if (value.getType() != type)
  return false;
// Integer values must be signless.
if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
  return false;
// Integer, float, and element attributes are buildable.
return value.isa<IntegerAttr, FloatAttr, ElementsAttr>();
138}

140OpFoldResult arith::ConstantOp::fold(ArrayRef<Attribute> operands) {
return getValue();
142}

144void arith::ConstantIntOp::build(OpBuilder &builder, OperationState &result,
                               int64_t value, unsigned width) {
auto type = builder.getIntegerType(width);
arith::ConstantOp::build(builder, result, type,
                         builder.getIntegerAttr(type, value));
149}

151void arith::ConstantIntOp::build(OpBuilder &builder, OperationState &result,
                               int64_t value, Type type) {
assert(type.isSignlessInteger() &&(static_cast <bool> (type.isSignlessInteger() &&
 "ConstantIntOp can only have signless integer type values") ?
 void (0) : __assert_fail ("type.isSignlessInteger() && \"ConstantIntOp can only have signless integer type values\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 154, __extension__
 __PRETTY_FUNCTION__))
       "ConstantIntOp can only have signless integer type values")(static_cast <bool> (type.isSignlessInteger() &&
 "ConstantIntOp can only have signless integer type values") ?
 void (0) : __assert_fail ("type.isSignlessInteger() && \"ConstantIntOp can only have signless integer type values\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 154, __extension__
 __PRETTY_FUNCTION__));
arith::ConstantOp::build(builder, result, type,
                         builder.getIntegerAttr(type, value));
157}

159bool arith::ConstantIntOp::classof(Operation *op) {
if (auto constOp = dyn_cast_or_null<arith::ConstantOp>(op))
  return constOp.getType().isSignlessInteger();
return false;
163}

165void arith::ConstantFloatOp::build(OpBuilder &builder, OperationState &result,
                                 const APFloat &value, FloatType type) {
arith::ConstantOp::build(builder, result, type,
                         builder.getFloatAttr(type, value));
169}

171bool arith::ConstantFloatOp::classof(Operation *op) {
if (auto constOp = dyn_cast_or_null<arith::ConstantOp>(op))
  return constOp.getType().isa<FloatType>();
return false;
175}

177void arith::ConstantIndexOp::build(OpBuilder &builder, OperationState &result,
                                 int64_t value) {
arith::ConstantOp::build(builder, result, builder.getIndexType(),
                         builder.getIndexAttr(value));
181}

183bool arith::ConstantIndexOp::classof(Operation *op) {
if (auto constOp = dyn_cast_or_null<arith::ConstantOp>(op))
  return constOp.getType().isIndex();
return false;
187}

189//===----------------------------------------------------------------------===//
190// AddIOp
191//===----------------------------------------------------------------------===//

193OpFoldResult arith::AddIOp::fold(ArrayRef<Attribute> operands) {
// addi(x, 0) -> x
if (matchPattern(getRhs(), m_Zero()))
  return getLhs();

// addi(subi(a, b), b) -> a
if (auto sub = getLhs().getDefiningOp<SubIOp>())
  if (getRhs() == sub.getRhs())
    return sub.getLhs();

// addi(b, subi(a, b)) -> a
if (auto sub = getRhs().getDefiningOp<SubIOp>())
  if (getLhs() == sub.getRhs())
    return sub.getLhs();

return constFoldBinaryOp<IntegerAttr>(
    operands, [](APInt a, const APInt &b) { return std::move(a) + b; });
210}

212void arith::AddIOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns.add<AddIAddConstant, AddISubConstantRHS, AddISubConstantLHS>(
    context);
216}

218//===----------------------------------------------------------------------===//
219// SubIOp
220//===----------------------------------------------------------------------===//

222OpFoldResult arith::SubIOp::fold(ArrayRef<Attribute> operands) {
// subi(x,x) -> 0
if (getOperand(0) == getOperand(1))
  return Builder(getContext()).getZeroAttr(getType());
// subi(x,0) -> x
if (matchPattern(getRhs(), m_Zero()))
  return getLhs();

return constFoldBinaryOp<IntegerAttr>(
    operands, [](APInt a, const APInt &b) { return std::move(a) - b; });
232}

234void arith::SubIOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns
    .add<SubIRHSAddConstant, SubILHSAddConstant, SubIRHSSubConstantRHS,
         SubIRHSSubConstantLHS, SubILHSSubConstantRHS, SubILHSSubConstantLHS>(
        context);
240}

242//===----------------------------------------------------------------------===//
243// MulIOp
244//===----------------------------------------------------------------------===//

246OpFoldResult arith::MulIOp::fold(ArrayRef<Attribute> operands) {
// muli(x, 0) -> 0
if (matchPattern(getRhs(), m_Zero()))
  return getRhs();
// muli(x, 1) -> x
if (matchPattern(getRhs(), m_One()))
  return getOperand(0);
// TODO: Handle the overflow case.

// default folder
return constFoldBinaryOp<IntegerAttr>(
    operands, [](const APInt &a, const APInt &b) { return a * b; });
258}

260//===----------------------------------------------------------------------===//
261// DivUIOp
262//===----------------------------------------------------------------------===//

264OpFoldResult arith::DivUIOp::fold(ArrayRef<Attribute> operands) {
// Don't fold if it would require a division by zero.
bool div0 = false;
auto result =
    constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, const APInt &b) {
      if (div0 || !b) {
        div0 = true;
        return a;
      }
      return a.udiv(b);
    });

// Fold out division by one. Assumes all tensors of all ones are splats.
if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
  if (rhs.getValue() == 1)
    return getLhs();
} else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
  if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
    return getLhs();
}

return div0 ? Attribute() : result;
286}

288//===----------------------------------------------------------------------===//
289// DivSIOp
290//===----------------------------------------------------------------------===//

292OpFoldResult arith::DivSIOp::fold(ArrayRef<Attribute> operands) {
// Don't fold if it would overflow or if it requires a division by zero.
bool overflowOrDiv0 = false;
auto result =
    constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, const APInt &b) {
      if (overflowOrDiv0 || !b) {
        overflowOrDiv0 = true;
        return a;
      }
      return a.sdiv_ov(b, overflowOrDiv0);
    });

// Fold out division by one. Assumes all tensors of all ones are splats.
if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
  if (rhs.getValue() == 1)
    return getLhs();
} else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
  if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
    return getLhs();
}

return overflowOrDiv0 ? Attribute() : result;
314}

316//===----------------------------------------------------------------------===//
317// Ceil and floor division folding helpers
318//===----------------------------------------------------------------------===//

320static APInt signedCeilNonnegInputs(const APInt &a, const APInt &b,
                                  bool &overflow) {
// Returns (a-1)/b + 1
APInt one(a.getBitWidth(), 1, true); // Signed value 1.
APInt val = a.ssub_ov(one, overflow).sdiv_ov(b, overflow);
return val.sadd_ov(one, overflow);
326}

328//===----------------------------------------------------------------------===//
329// CeilDivUIOp
330//===----------------------------------------------------------------------===//

332OpFoldResult arith::CeilDivUIOp::fold(ArrayRef<Attribute> operands) {
bool overflowOrDiv0 = false;
auto result =
    constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, const APInt &b) {
      if (overflowOrDiv0 || !b) {
        overflowOrDiv0 = true;
        return a;
      }
      APInt quotient = a.udiv(b);
      if (!a.urem(b))
        return quotient;
      APInt one(a.getBitWidth(), 1, true);
      return quotient.uadd_ov(one, overflowOrDiv0);
    });
// Fold out ceil division by one. Assumes all tensors of all ones are
// splats.
if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
  if (rhs.getValue() == 1)
    return getLhs();
} else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
  if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
    return getLhs();
}

return overflowOrDiv0 ? Attribute() : result;
357}

359//===----------------------------------------------------------------------===//
360// CeilDivSIOp
361//===----------------------------------------------------------------------===//

363OpFoldResult arith::CeilDivSIOp::fold(ArrayRef<Attribute> operands) {
// Don't fold if it would overflow or if it requires a division by zero.
bool overflowOrDiv0 = false;
auto result =
    constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, const APInt &b) {
      if (overflowOrDiv0 || !b) {
        overflowOrDiv0 = true;
        return a;
      }
      if (!a)
        return a;
      // After this point we know that neither a or b are zero.
      unsigned bits = a.getBitWidth();
      APInt zero = APInt::getZero(bits);
      bool aGtZero = a.sgt(zero);
      bool bGtZero = b.sgt(zero);
      if (aGtZero && bGtZero) {
        // Both positive, return ceil(a, b).
        return signedCeilNonnegInputs(a, b, overflowOrDiv0);
      }
      if (!aGtZero && !bGtZero) {
        // Both negative, return ceil(-a, -b).
        APInt posA = zero.ssub_ov(a, overflowOrDiv0);
        APInt posB = zero.ssub_ov(b, overflowOrDiv0);
        return signedCeilNonnegInputs(posA, posB, overflowOrDiv0);
      }
      if (!aGtZero && bGtZero) {
        // A is negative, b is positive, return - ( -a / b).
        APInt posA = zero.ssub_ov(a, overflowOrDiv0);
        APInt div = posA.sdiv_ov(b, overflowOrDiv0);
        return zero.ssub_ov(div, overflowOrDiv0);
      }
      // A is positive, b is negative, return - (a / -b).
      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
      APInt div = a.sdiv_ov(posB, overflowOrDiv0);
      return zero.ssub_ov(div, overflowOrDiv0);
    });

// Fold out ceil division by one. Assumes all tensors of all ones are
// splats.
if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
  if (rhs.getValue() == 1)
    return getLhs();
} else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
  if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
    return getLhs();
}

return overflowOrDiv0 ? Attribute() : result;
412}

414//===----------------------------------------------------------------------===//
415// FloorDivSIOp
416//===----------------------------------------------------------------------===//

418OpFoldResult arith::FloorDivSIOp::fold(ArrayRef<Attribute> operands) {
// Don't fold if it would overflow or if it requires a division by zero.
bool overflowOrDiv0 = false;
auto result =
    constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, const APInt &b) {
      if (overflowOrDiv0 || !b) {
        overflowOrDiv0 = true;
        return a;
      }
      if (!a)
        return a;
      // After this point we know that neither a or b are zero.
      unsigned bits = a.getBitWidth();
      APInt zero = APInt::getZero(bits);
      bool aGtZero = a.sgt(zero);
      bool bGtZero = b.sgt(zero);
      if (aGtZero && bGtZero) {
        // Both positive, return a / b.
        return a.sdiv_ov(b, overflowOrDiv0);
      }
      if (!aGtZero && !bGtZero) {
        // Both negative, return -a / -b.
        APInt posA = zero.ssub_ov(a, overflowOrDiv0);
        APInt posB = zero.ssub_ov(b, overflowOrDiv0);
        return posA.sdiv_ov(posB, overflowOrDiv0);
      }
      if (!aGtZero && bGtZero) {
        // A is negative, b is positive, return - ceil(-a, b).
        APInt posA = zero.ssub_ov(a, overflowOrDiv0);
        APInt ceil = signedCeilNonnegInputs(posA, b, overflowOrDiv0);
        return zero.ssub_ov(ceil, overflowOrDiv0);
      }
      // A is positive, b is negative, return - ceil(a, -b).
      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
      APInt ceil = signedCeilNonnegInputs(a, posB, overflowOrDiv0);
      return zero.ssub_ov(ceil, overflowOrDiv0);
    });

// Fold out floor division by one. Assumes all tensors of all ones are
// splats.
if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
  if (rhs.getValue() == 1)
    return getLhs();
} else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
  if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
    return getLhs();
}

return overflowOrDiv0 ? Attribute() : result;
467}

469//===----------------------------------------------------------------------===//
470// RemUIOp
471//===----------------------------------------------------------------------===//

473OpFoldResult arith::RemUIOp::fold(ArrayRef<Attribute> operands) {
auto rhs = operands.back().dyn_cast_or_null<IntegerAttr>();
if (!rhs)
  return {};
auto rhsValue = rhs.getValue();

// x % 1 = 0
if (rhsValue.isOneValue())
  return IntegerAttr::get(rhs.getType(), APInt(rhsValue.getBitWidth(), 0));

// Don't fold if it requires division by zero.
if (rhsValue.isNullValue())
  return {};

auto lhs = operands.front().dyn_cast_or_null<IntegerAttr>();
if (!lhs)
  return {};
return IntegerAttr::get(lhs.getType(), lhs.getValue().urem(rhsValue));
491}

493//===----------------------------------------------------------------------===//
494// RemSIOp
495//===----------------------------------------------------------------------===//

497OpFoldResult arith::RemSIOp::fold(ArrayRef<Attribute> operands) {
auto rhs = operands.back().dyn_cast_or_null<IntegerAttr>();
if (!rhs)
  return {};
auto rhsValue = rhs.getValue();

// x % 1 = 0
if (rhsValue.isOneValue())
  return IntegerAttr::get(rhs.getType(), APInt(rhsValue.getBitWidth(), 0));

// Don't fold if it requires division by zero.
if (rhsValue.isNullValue())
  return {};

auto lhs = operands.front().dyn_cast_or_null<IntegerAttr>();
if (!lhs)
  return {};
return IntegerAttr::get(lhs.getType(), lhs.getValue().srem(rhsValue));
515}

517//===----------------------------------------------------------------------===//
518// AndIOp
519//===----------------------------------------------------------------------===//

521OpFoldResult arith::AndIOp::fold(ArrayRef<Attribute> operands) {
/// and(x, 0) -> 0
if (matchPattern(getRhs(), m_Zero()))
  return getRhs();
/// and(x, allOnes) -> x
APInt intValue;
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isAllOnes())
  return getLhs();

return constFoldBinaryOp<IntegerAttr>(
    operands, [](APInt a, const APInt &b) { return std::move(a) & b; });
532}

534//===----------------------------------------------------------------------===//
535// OrIOp
536//===----------------------------------------------------------------------===//

538OpFoldResult arith::OrIOp::fold(ArrayRef<Attribute> operands) {
/// or(x, 0) -> x
if (matchPattern(getRhs(), m_Zero()))
  return getLhs();
/// or(x, <all ones>) -> <all ones>
if (auto rhsAttr = operands[1].dyn_cast_or_null<IntegerAttr>())
  if (rhsAttr.getValue().isAllOnes())
    return rhsAttr;

return constFoldBinaryOp<IntegerAttr>(
    operands, [](APInt a, const APInt &b) { return std::move(a) | b; });
549}

551//===----------------------------------------------------------------------===//
552// XOrIOp
553//===----------------------------------------------------------------------===//

555OpFoldResult arith::XOrIOp::fold(ArrayRef<Attribute> operands) {
/// xor(x, 0) -> x
if (matchPattern(getRhs(), m_Zero()))
  return getLhs();
/// xor(x, x) -> 0
if (getLhs() == getRhs())
  return Builder(getContext()).getZeroAttr(getType());
/// xor(xor(x, a), a) -> x
if (arith::XOrIOp prev = getLhs().getDefiningOp<arith::XOrIOp>())
  if (prev.getRhs() == getRhs())
    return prev.getLhs();

return constFoldBinaryOp<IntegerAttr>(
    operands, [](APInt a, const APInt &b) { return std::move(a) ^ b; });
569}

571void arith::XOrIOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns.add<XOrINotCmpI>(context);
574}

576//===----------------------------------------------------------------------===//
577// NegFOp
578//===----------------------------------------------------------------------===//

580OpFoldResult arith::NegFOp::fold(ArrayRef<Attribute> operands) {
return constFoldUnaryOp<FloatAttr>(operands,
                                   [](const APFloat &a) { return -a; });
583}

585//===----------------------------------------------------------------------===//
586// AddFOp
587//===----------------------------------------------------------------------===//

589OpFoldResult arith::AddFOp::fold(ArrayRef<Attribute> operands) {
// addf(x, -0) -> x
if (matchPattern(getRhs(), m_NegZeroFloat()))
  return getLhs();

return constFoldBinaryOp<FloatAttr>(
    operands, [](const APFloat &a, const APFloat &b) { return a + b; });
596}

598//===----------------------------------------------------------------------===//
599// SubFOp
600//===----------------------------------------------------------------------===//

602OpFoldResult arith::SubFOp::fold(ArrayRef<Attribute> operands) {
// subf(x, +0) -> x
if (matchPattern(getRhs(), m_PosZeroFloat()))
  return getLhs();

return constFoldBinaryOp<FloatAttr>(
    operands, [](const APFloat &a, const APFloat &b) { return a - b; });
609}

611//===----------------------------------------------------------------------===//
612// MaxFOp
613//===----------------------------------------------------------------------===//

615OpFoldResult arith::MaxFOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "maxf takes two operands")(static_cast <bool> (operands.size() == 2 && "maxf takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"maxf takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 616, __extension__
 __PRETTY_FUNCTION__));

// maxf(x,x) -> x
if (getLhs() == getRhs())
  return getRhs();

// maxf(x, -inf) -> x
if (matchPattern(getRhs(), m_NegInfFloat()))
  return getLhs();

return constFoldBinaryOp<FloatAttr>(
    operands,
    [](const APFloat &a, const APFloat &b) { return llvm::maximum(a, b); });
629}

631//===----------------------------------------------------------------------===//
632// MaxSIOp
633//===----------------------------------------------------------------------===//

635OpFoldResult MaxSIOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "binary operation takes two operands")(static_cast <bool> (operands.size() == 2 && "binary operation takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"binary operation takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 636, __extension__
 __PRETTY_FUNCTION__));

// maxsi(x,x) -> x
if (getLhs() == getRhs())
  return getRhs();

APInt intValue;
// maxsi(x,MAX_INT) -> MAX_INT
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
    intValue.isMaxSignedValue())
  return getRhs();

// maxsi(x, MIN_INT) -> x
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
    intValue.isMinSignedValue())
  return getLhs();

return constFoldBinaryOp<IntegerAttr>(operands,
                                      [](const APInt &a, const APInt &b) {
                                        return llvm::APIntOps::smax(a, b);
                                      });
657}

659//===----------------------------------------------------------------------===//
660// MaxUIOp
661//===----------------------------------------------------------------------===//

663OpFoldResult MaxUIOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "binary operation takes two operands")(static_cast <bool> (operands.size() == 2 && "binary operation takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"binary operation takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 664, __extension__
 __PRETTY_FUNCTION__));

// maxui(x,x) -> x
if (getLhs() == getRhs())
  return getRhs();

APInt intValue;
// maxui(x,MAX_INT) -> MAX_INT
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
  return getRhs();

// maxui(x, MIN_INT) -> x
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
  return getLhs();

return constFoldBinaryOp<IntegerAttr>(operands,
                                      [](const APInt &a, const APInt &b) {
                                        return llvm::APIntOps::umax(a, b);
                                      });
683}

685//===----------------------------------------------------------------------===//
686// MinFOp
687//===----------------------------------------------------------------------===//

689OpFoldResult arith::MinFOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "minf takes two operands")(static_cast <bool> (operands.size() == 2 && "minf takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"minf takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 690, __extension__
 __PRETTY_FUNCTION__));

// minf(x,x) -> x
if (getLhs() == getRhs())
  return getRhs();

// minf(x, +inf) -> x
if (matchPattern(getRhs(), m_PosInfFloat()))
  return getLhs();

return constFoldBinaryOp<FloatAttr>(
    operands,
    [](const APFloat &a, const APFloat &b) { return llvm::minimum(a, b); });
703}

705//===----------------------------------------------------------------------===//
706// MinSIOp
707//===----------------------------------------------------------------------===//

709OpFoldResult MinSIOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "binary operation takes two operands")(static_cast <bool> (operands.size() == 2 && "binary operation takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"binary operation takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 710, __extension__
 __PRETTY_FUNCTION__));

// minsi(x,x) -> x
if (getLhs() == getRhs())
  return getRhs();

APInt intValue;
// minsi(x,MIN_INT) -> MIN_INT
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
    intValue.isMinSignedValue())
  return getRhs();

// minsi(x, MAX_INT) -> x
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
    intValue.isMaxSignedValue())
  return getLhs();

return constFoldBinaryOp<IntegerAttr>(operands,
                                      [](const APInt &a, const APInt &b) {
                                        return llvm::APIntOps::smin(a, b);
                                      });
731}

733//===----------------------------------------------------------------------===//
734// MinUIOp
735//===----------------------------------------------------------------------===//

737OpFoldResult MinUIOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "binary operation takes two operands")(static_cast <bool> (operands.size() == 2 && "binary operation takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"binary operation takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 738, __extension__
 __PRETTY_FUNCTION__));

// minui(x,x) -> x
if (getLhs() == getRhs())
  return getRhs();

APInt intValue;
// minui(x,MIN_INT) -> MIN_INT
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
  return getRhs();

// minui(x, MAX_INT) -> x
if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
  return getLhs();

return constFoldBinaryOp<IntegerAttr>(operands,
                                      [](const APInt &a, const APInt &b) {
                                        return llvm::APIntOps::umin(a, b);
                                      });
757}

759//===----------------------------------------------------------------------===//
760// MulFOp
761//===----------------------------------------------------------------------===//

763OpFoldResult arith::MulFOp::fold(ArrayRef<Attribute> operands) {
// mulf(x, 1) -> x
if (matchPattern(getRhs(), m_OneFloat()))
  return getLhs();

return constFoldBinaryOp<FloatAttr>(
    operands, [](const APFloat &a, const APFloat &b) { return a * b; });
770}

772//===----------------------------------------------------------------------===//
773// DivFOp
774//===----------------------------------------------------------------------===//

776OpFoldResult arith::DivFOp::fold(ArrayRef<Attribute> operands) {
// divf(x, 1) -> x
if (matchPattern(getRhs(), m_OneFloat()))
  return getLhs();

return constFoldBinaryOp<FloatAttr>(
    operands, [](const APFloat &a, const APFloat &b) { return a / b; });
783}

785//===----------------------------------------------------------------------===//
786// Utility functions for verifying cast ops
787//===----------------------------------------------------------------------===//

789template <typename... Types>
790using type_list = std::tuple<Types...> *;

792/// Returns a non-null type only if the provided type is one of the allowed
793/// types or one of the allowed shaped types of the allowed types. Returns the
794/// element type if a valid shaped type is provided.
795template <typename... ShapedTypes, typename... ElementTypes>
796static Type getUnderlyingType(Type type, type_list<ShapedTypes...>,
                            type_list<ElementTypes...>) {
if (type.isa<ShapedType>() && !type.isa<ShapedTypes...>())
  return {};

auto underlyingType = getElementTypeOrSelf(type);
if (!underlyingType.isa<ElementTypes...>())
  return {};

return underlyingType;
806}

808/// Get allowed underlying types for vectors and tensors.
809template <typename... ElementTypes>
810static Type getTypeIfLike(Type type) {
return getUnderlyingType(type, type_list<VectorType, TensorType>(),
                         type_list<ElementTypes...>());
813}

815/// Get allowed underlying types for vectors, tensors, and memrefs.
816template <typename... ElementTypes>
817static Type getTypeIfLikeOrMemRef(Type type) {
return getUnderlyingType(type,
                         type_list<VectorType, TensorType, MemRefType>(),
                         type_list<ElementTypes...>());
821}

823static bool areValidCastInputsAndOutputs(TypeRange inputs, TypeRange outputs) {
return inputs.size() == 1 && outputs.size() == 1 &&
       succeeded(verifyCompatibleShapes(inputs.front(), outputs.front()));
826}

828//===----------------------------------------------------------------------===//
829// Verifiers for integer and floating point extension/truncation ops
830//===----------------------------------------------------------------------===//

832// Extend ops can only extend to a wider type.
833template <typename ValType, typename Op>
834static LogicalResult verifyExtOp(Op op) {
Type srcType = getElementTypeOrSelf(op.getIn().getType());
Type dstType = getElementTypeOrSelf(op.getType());

if (srcType.cast<ValType>().getWidth() >= dstType.cast<ValType>().getWidth())
  return op.emitError("result type ")
         << dstType << " must be wider than operand type " << srcType;

return success();
843}

845// Truncate ops can only truncate to a shorter type.
846template <typename ValType, typename Op>
847static LogicalResult verifyTruncateOp(Op op) {
Type srcType = getElementTypeOrSelf(op.getIn().getType());
Type dstType = getElementTypeOrSelf(op.getType());

if (srcType.cast<ValType>().getWidth() <= dstType.cast<ValType>().getWidth())
  return op.emitError("result type ")
         << dstType << " must be shorter than operand type " << srcType;

return success();
856}

858/// Validate a cast that changes the width of a type.
859template <template <typename> class WidthComparator, typename... ElementTypes>
860static bool checkWidthChangeCast(TypeRange inputs, TypeRange outputs) {
if (!areValidCastInputsAndOutputs(inputs, outputs))
  return false;

auto srcType = getTypeIfLike<ElementTypes...>(inputs.front());
auto dstType = getTypeIfLike<ElementTypes...>(outputs.front());
if (!srcType || !dstType)
  return false;

return WidthComparator<unsigned>()(dstType.getIntOrFloatBitWidth(),
                                   srcType.getIntOrFloatBitWidth());
871}

873//===----------------------------------------------------------------------===//
874// ExtUIOp
875//===----------------------------------------------------------------------===//

877OpFoldResult arith::ExtUIOp::fold(ArrayRef<Attribute> operands) {
if (auto lhs = getIn().getDefiningOp<ExtUIOp>()) {
  getInMutable().assign(lhs.getIn());
  return getResult();
}
Type resType = getType();
unsigned bitWidth;
if (auto shapedType = resType.dyn_cast<ShapedType>())
  bitWidth = shapedType.getElementTypeBitWidth();
else
  bitWidth = resType.getIntOrFloatBitWidth();
return constFoldCastOp<IntegerAttr, IntegerAttr>(
    operands, getType(), [bitWidth](const APInt &a, bool &castStatus) {
      return a.zext(bitWidth);
    });
892}

894bool arith::ExtUIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkWidthChangeCast<std::greater, IntegerType>(inputs, outputs);
896}

898LogicalResult arith::ExtUIOp::verify() {
return verifyExtOp<IntegerType>(*this);
900}

902//===----------------------------------------------------------------------===//
903// ExtSIOp
904//===----------------------------------------------------------------------===//

906OpFoldResult arith::ExtSIOp::fold(ArrayRef<Attribute> operands) {
if (auto lhs = getIn().getDefiningOp<ExtSIOp>()) {
  getInMutable().assign(lhs.getIn());
  return getResult();
}
Type resType = getType();
unsigned bitWidth;
if (auto shapedType = resType.dyn_cast<ShapedType>())
  bitWidth = shapedType.getElementTypeBitWidth();
else
  bitWidth = resType.getIntOrFloatBitWidth();
return constFoldCastOp<IntegerAttr, IntegerAttr>(
    operands, getType(), [bitWidth](const APInt &a, bool &castStatus) {
      return a.sext(bitWidth);
    });
921}

923bool arith::ExtSIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkWidthChangeCast<std::greater, IntegerType>(inputs, outputs);
925}

927void arith::ExtSIOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns.add<ExtSIOfExtUI>(context);
930}

932LogicalResult arith::ExtSIOp::verify() {
return verifyExtOp<IntegerType>(*this);
934}

936//===----------------------------------------------------------------------===//
937// ExtFOp
938//===----------------------------------------------------------------------===//

940bool arith::ExtFOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkWidthChangeCast<std::greater, FloatType>(inputs, outputs);
942}

944LogicalResult arith::ExtFOp::verify() { return verifyExtOp<FloatType>(*this); }

946//===----------------------------------------------------------------------===//
947// TruncIOp
948//===----------------------------------------------------------------------===//

950OpFoldResult arith::TruncIOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 1 && "unary operation takes one operand")(static_cast <bool> (operands.size() == 1 && "unary operation takes one operand"
) ? void (0) : __assert_fail ("operands.size() == 1 && \"unary operation takes one operand\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 951, __extension__
 __PRETTY_FUNCTION__));

// trunci(zexti(a)) -> a
// trunci(sexti(a)) -> a
if (matchPattern(getOperand(), m_Op<arith::ExtUIOp>()) ||
    matchPattern(getOperand(), m_Op<arith::ExtSIOp>()))
  return getOperand().getDefiningOp()->getOperand(0);

// trunci(trunci(a)) -> trunci(a))
if (matchPattern(getOperand(), m_Op<arith::TruncIOp>())) {
  setOperand(getOperand().getDefiningOp()->getOperand(0));
  return getResult();
}

Type resType = getType();
unsigned bitWidth;
if (auto shapedType = resType.dyn_cast<ShapedType>())
  bitWidth = shapedType.getElementTypeBitWidth();
else
  bitWidth = resType.getIntOrFloatBitWidth();

return constFoldCastOp<IntegerAttr, IntegerAttr>(
    operands, getType(), [bitWidth](const APInt &a, bool &castStatus) {
      return a.trunc(bitWidth);
    });
976}

978bool arith::TruncIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkWidthChangeCast<std::less, IntegerType>(inputs, outputs);
980}

982LogicalResult arith::TruncIOp::verify() {
return verifyTruncateOp<IntegerType>(*this);
984}

986//===----------------------------------------------------------------------===//
987// TruncFOp
988//===----------------------------------------------------------------------===//

990/// Perform safe const propagation for truncf, i.e. only propagate if FP value
991/// can be represented without precision loss or rounding.
992OpFoldResult arith::TruncFOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 1 && "unary operation takes one operand")(static_cast <bool> (operands.size() == 1 && "unary operation takes one operand"
) ? void (0) : __assert_fail ("operands.size() == 1 && \"unary operation takes one operand\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 993, __extension__
 __PRETTY_FUNCTION__));

auto constOperand = operands.front();
if (!constOperand || !constOperand.isa<FloatAttr>())
  return {};

// Convert to target type via 'double'.
double sourceValue =
    constOperand.dyn_cast<FloatAttr>().getValue().convertToDouble();
auto targetAttr = FloatAttr::get(getType(), sourceValue);

// Propagate if constant's value does not change after truncation.
if (sourceValue == targetAttr.getValue().convertToDouble())
  return targetAttr;

return {};
1009}

1011bool arith::TruncFOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkWidthChangeCast<std::less, FloatType>(inputs, outputs);
1013}

1015LogicalResult arith::TruncFOp::verify() {
return verifyTruncateOp<FloatType>(*this);
1017}

1019//===----------------------------------------------------------------------===//
1020// AndIOp
1021//===----------------------------------------------------------------------===//

1023void arith::AndIOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns.add<AndOfExtUI, AndOfExtSI>(context);
1026}

1028//===----------------------------------------------------------------------===//
1029// OrIOp
1030//===----------------------------------------------------------------------===//

1032void arith::OrIOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns.add<OrOfExtUI, OrOfExtSI>(context);
1035}

1037//===----------------------------------------------------------------------===//
1038// Verifiers for casts between integers and floats.
1039//===----------------------------------------------------------------------===//

1041template <typename From, typename To>
1042static bool checkIntFloatCast(TypeRange inputs, TypeRange outputs) {
if (!areValidCastInputsAndOutputs(inputs, outputs))
  return false;

auto srcType = getTypeIfLike<From>(inputs.front());
auto dstType = getTypeIfLike<To>(outputs.back());

return srcType && dstType;
1050}

1052//===----------------------------------------------------------------------===//
1053// UIToFPOp
1054//===----------------------------------------------------------------------===//

1056bool arith::UIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkIntFloatCast<IntegerType, FloatType>(inputs, outputs);
1058}

1060OpFoldResult arith::UIToFPOp::fold(ArrayRef<Attribute> operands) {
Type resType = getType();
Type resEleType;
if (auto shapedType = resType.dyn_cast<ShapedType>())
  resEleType = shapedType.getElementType();
else
  resEleType = resType;
return constFoldCastOp<IntegerAttr, FloatAttr>(
    operands, getType(), [&resEleType](const APInt &a, bool &castStatus) {
      FloatType floatTy = resEleType.cast<FloatType>();
      APFloat apf(floatTy.getFloatSemantics(),
                  APInt::getZero(floatTy.getWidth()));
      apf.convertFromAPInt(a, /*IsSigned=*/false,
                           APFloat::rmNearestTiesToEven);
      return apf;
    });
1076}

1078//===----------------------------------------------------------------------===//
1079// SIToFPOp
1080//===----------------------------------------------------------------------===//

1082bool arith::SIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkIntFloatCast<IntegerType, FloatType>(inputs, outputs);
1084}

1086OpFoldResult arith::SIToFPOp::fold(ArrayRef<Attribute> operands) {
Type resType = getType();
Type resEleType;
if (auto shapedType = resType.dyn_cast<ShapedType>())
  resEleType = shapedType.getElementType();
else
  resEleType = resType;
return constFoldCastOp<IntegerAttr, FloatAttr>(
    operands, getType(), [&resEleType](const APInt &a, bool &castStatus) {
      FloatType floatTy = resEleType.cast<FloatType>();
      APFloat apf(floatTy.getFloatSemantics(),
                  APInt::getZero(floatTy.getWidth()));
      apf.convertFromAPInt(a, /*IsSigned=*/true,
                           APFloat::rmNearestTiesToEven);
      return apf;
    });
1102}
1103//===----------------------------------------------------------------------===//
1104// FPToUIOp
1105//===----------------------------------------------------------------------===//

1107bool arith::FPToUIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkIntFloatCast<FloatType, IntegerType>(inputs, outputs);
1109}

1111OpFoldResult arith::FPToUIOp::fold(ArrayRef<Attribute> operands) {
Type resType = getType();
Type resEleType;
if (auto shapedType = resType.dyn_cast<ShapedType>())
  resEleType = shapedType.getElementType();
else
  resEleType = resType;
return constFoldCastOp<FloatAttr, IntegerAttr>(
    operands, getType(), [&resEleType](const APFloat &a, bool &castStatus) {
      IntegerType intTy = resEleType.cast<IntegerType>();
      bool ignored;
      APSInt api(intTy.getWidth(), /*isUnsigned=*/true);
      castStatus = APFloat::opInvalidOp !=
                   a.convertToInteger(api, APFloat::rmTowardZero, &ignored);
      return api;
    });
1127}

1129//===----------------------------------------------------------------------===//
1130// FPToSIOp
1131//===----------------------------------------------------------------------===//

1133bool arith::FPToSIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
return checkIntFloatCast<FloatType, IntegerType>(inputs, outputs);
1135}

1137OpFoldResult arith::FPToSIOp::fold(ArrayRef<Attribute> operands) {
Type resType = getType();
Type resEleType;
if (auto shapedType = resType.dyn_cast<ShapedType>())
  resEleType = shapedType.getElementType();
else
  resEleType = resType;
return constFoldCastOp<FloatAttr, IntegerAttr>(
    operands, getType(), [&resEleType](const APFloat &a, bool &castStatus) {
      IntegerType intTy = resEleType.cast<IntegerType>();
      bool ignored;
      APSInt api(intTy.getWidth(), /*isUnsigned=*/false);
      castStatus = APFloat::opInvalidOp !=
                   a.convertToInteger(api, APFloat::rmTowardZero, &ignored);
      return api;
    });
1153}

1155//===----------------------------------------------------------------------===//
1156// IndexCastOp
1157//===----------------------------------------------------------------------===//

1159bool arith::IndexCastOp::areCastCompatible(TypeRange inputs,
                                         TypeRange outputs) {
if (!areValidCastInputsAndOutputs(inputs, outputs))
  return false;

auto srcType = getTypeIfLikeOrMemRef<IntegerType, IndexType>(inputs.front());
auto dstType = getTypeIfLikeOrMemRef<IntegerType, IndexType>(outputs.front());
if (!srcType || !dstType)
  return false;

return (srcType.isIndex() && dstType.isSignlessInteger()) ||
       (srcType.isSignlessInteger() && dstType.isIndex());
1171}

1173OpFoldResult arith::IndexCastOp::fold(ArrayRef<Attribute> operands) {
// index_cast(constant) -> constant
// A little hack because we go through int. Otherwise, the size of the
// constant might need to change.
if (auto value = operands[0].dyn_cast_or_null<IntegerAttr>())
  return IntegerAttr::get(getType(), value.getInt());

return {};
1181}

1183void arith::IndexCastOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns.add<IndexCastOfIndexCast, IndexCastOfExtSI>(context);
1186}

1188//===----------------------------------------------------------------------===//
1189// BitcastOp
1190//===----------------------------------------------------------------------===//

1192bool arith::BitcastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
if (!areValidCastInputsAndOutputs(inputs, outputs))
  return false;

auto srcType =
    getTypeIfLikeOrMemRef<IntegerType, IndexType, FloatType>(inputs.front());
auto dstType =
    getTypeIfLikeOrMemRef<IntegerType, IndexType, FloatType>(outputs.front());
if (!srcType || !dstType)
  return false;

return srcType.getIntOrFloatBitWidth() == dstType.getIntOrFloatBitWidth();
1204}

1206OpFoldResult arith::BitcastOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 1 && "bitcast op expects 1 operand")(static_cast <bool> (operands.size() == 1 && "bitcast op expects 1 operand"
) ? void (0) : __assert_fail ("operands.size() == 1 && \"bitcast op expects 1 operand\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 1207, __extension__
 __PRETTY_FUNCTION__));

auto resType = getType();
auto operand = operands[0];
if (!operand)
  return {};

/// Bitcast dense elements.
if (auto denseAttr = operand.dyn_cast_or_null<DenseElementsAttr>())
  return denseAttr.bitcast(resType.cast<ShapedType>().getElementType());
/// Other shaped types unhandled.
if (resType.isa<ShapedType>())
  return {};

/// Bitcast integer or float to integer or float.
APInt bits = operand.isa<FloatAttr>()
                 ? operand.cast<FloatAttr>().getValue().bitcastToAPInt()
                 : operand.cast<IntegerAttr>().getValue();

if (auto resFloatType = resType.dyn_cast<FloatType>())
  return FloatAttr::get(resType,
                        APFloat(resFloatType.getFloatSemantics(), bits));
return IntegerAttr::get(resType, bits);
1230}

1232void arith::BitcastOp::getCanonicalizationPatterns(
  RewritePatternSet &patterns, MLIRContext *context) {
patterns.add<BitcastOfBitcast>(context);
1235}

1237//===----------------------------------------------------------------------===//
1238// Helpers for compare ops
1239//===----------------------------------------------------------------------===//

1241/// Return the type of the same shape (scalar, vector or tensor) containing i1.
1242static Type getI1SameShape(Type type) {
auto i1Type = IntegerType::get(type.getContext(), 1);
if (auto tensorType = type.dyn_cast<RankedTensorType>())
  return RankedTensorType::get(tensorType.getShape(), i1Type);
if (type.isa<UnrankedTensorType>())
  return UnrankedTensorType::get(i1Type);
if (auto vectorType = type.dyn_cast<VectorType>())
  return VectorType::get(vectorType.getShape(), i1Type,
                         vectorType.getNumScalableDims());
return i1Type;
1252}

1254//===----------------------------------------------------------------------===//
1255// CmpIOp
1256//===----------------------------------------------------------------------===//

1258/// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
1259/// comparison predicates.
1260bool mlir::arith::applyCmpPredicate(arith::CmpIPredicate predicate,
                                  const APInt &lhs, const APInt &rhs) {
switch (predicate) {
case arith::CmpIPredicate::eq:
  return lhs.eq(rhs);
case arith::CmpIPredicate::ne:
  return lhs.ne(rhs);
case arith::CmpIPredicate::slt:
  return lhs.slt(rhs);
case arith::CmpIPredicate::sle:
  return lhs.sle(rhs);
case arith::CmpIPredicate::sgt:
  return lhs.sgt(rhs);
case arith::CmpIPredicate::sge:
  return lhs.sge(rhs);
case arith::CmpIPredicate::ult:
  return lhs.ult(rhs);
case arith::CmpIPredicate::ule:
  return lhs.ule(rhs);
case arith::CmpIPredicate::ugt:
  return lhs.ugt(rhs);
case arith::CmpIPredicate::uge:
  return lhs.uge(rhs);
}
llvm_unreachable("unknown cmpi predicate kind")::llvm::llvm_unreachable_internal("unknown cmpi predicate kind"
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 1284);
1285}

1287/// Returns true if the predicate is true for two equal operands.
1288static bool applyCmpPredicateToEqualOperands(arith::CmpIPredicate predicate) {
switch (predicate) {
case arith::CmpIPredicate::eq:
case arith::CmpIPredicate::sle:
case arith::CmpIPredicate::sge:
case arith::CmpIPredicate::ule:
case arith::CmpIPredicate::uge:
  return true;
case arith::CmpIPredicate::ne:
case arith::CmpIPredicate::slt:
case arith::CmpIPredicate::sgt:
case arith::CmpIPredicate::ult:
case arith::CmpIPredicate::ugt:
  return false;
}
llvm_unreachable("unknown cmpi predicate kind")::llvm::llvm_unreachable_internal("unknown cmpi predicate kind"
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 1303);
1304}

1306static Attribute getBoolAttribute(Type type, MLIRContext *ctx, bool value) {
auto boolAttr = BoolAttr::get(ctx, value);
ShapedType shapedType = type.dyn_cast_or_null<ShapedType>();
if (!shapedType)
  return boolAttr;
return DenseElementsAttr::get(shapedType, boolAttr);
1312}

1314OpFoldResult arith::CmpIOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "cmpi takes two operands")(static_cast <bool> (operands.size() == 2 && "cmpi takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"cmpi takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 1315, __extension__
 __PRETTY_FUNCTION__));

// cmpi(pred, x, x)
if (getLhs() == getRhs()) {
  auto val = applyCmpPredicateToEqualOperands(getPredicate());
  return getBoolAttribute(getType(), getContext(), val);
}

if (matchPattern(getRhs(), m_Zero())) {
  if (auto extOp = getLhs().getDefiningOp<ExtSIOp>()) {
    if (extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1) {
      // extsi(%x : i1 -> iN) != 0  ->  %x
      if (getPredicate() == arith::CmpIPredicate::ne) {
        return extOp.getOperand();
      }
    }
  }
  if (auto extOp = getLhs().getDefiningOp<ExtUIOp>()) {
    if (extOp.getOperand().getType().cast<IntegerType>().getWidth() == 1) {
      // extui(%x : i1 -> iN) != 0  ->  %x
      if (getPredicate() == arith::CmpIPredicate::ne) {
        return extOp.getOperand();
      }
    }
  }
}

auto lhs = operands.front().dyn_cast_or_null<IntegerAttr>();
auto rhs = operands.back().dyn_cast_or_null<IntegerAttr>();
if (!lhs || !rhs)
  return {};

auto val = applyCmpPredicate(getPredicate(), lhs.getValue(), rhs.getValue());
return BoolAttr::get(getContext(), val);
1349}

1351void arith::CmpIOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                              MLIRContext *context) {
patterns.insert<CmpIExtSI, CmpIExtUI>(context);
1354}

1356//===----------------------------------------------------------------------===//
1357// CmpFOp
1358//===----------------------------------------------------------------------===//

1360/// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
1361/// comparison predicates.
1362bool mlir::arith::applyCmpPredicate(arith::CmpFPredicate predicate,
                                  const APFloat &lhs, const APFloat &rhs) {
auto cmpResult = lhs.compare(rhs);
switch (predicate) {
case arith::CmpFPredicate::AlwaysFalse:
  return false;
case arith::CmpFPredicate::OEQ:
  return cmpResult == APFloat::cmpEqual;
case arith::CmpFPredicate::OGT:
  return cmpResult == APFloat::cmpGreaterThan;
case arith::CmpFPredicate::OGE:
  return cmpResult == APFloat::cmpGreaterThan ||
         cmpResult == APFloat::cmpEqual;
case arith::CmpFPredicate::OLT:
  return cmpResult == APFloat::cmpLessThan;
case arith::CmpFPredicate::OLE:
  return cmpResult == APFloat::cmpLessThan || cmpResult == APFloat::cmpEqual;
case arith::CmpFPredicate::ONE:
  return cmpResult != APFloat::cmpUnordered && cmpResult != APFloat::cmpEqual;
case arith::CmpFPredicate::ORD:
  return cmpResult != APFloat::cmpUnordered;
case arith::CmpFPredicate::UEQ:
  return cmpResult == APFloat::cmpUnordered || cmpResult == APFloat::cmpEqual;
case arith::CmpFPredicate::UGT:
  return cmpResult == APFloat::cmpUnordered ||
         cmpResult == APFloat::cmpGreaterThan;
case arith::CmpFPredicate::UGE:
  return cmpResult == APFloat::cmpUnordered ||
         cmpResult == APFloat::cmpGreaterThan ||
         cmpResult == APFloat::cmpEqual;
case arith::CmpFPredicate::ULT:
  return cmpResult == APFloat::cmpUnordered ||
         cmpResult == APFloat::cmpLessThan;
case arith::CmpFPredicate::ULE:
  return cmpResult == APFloat::cmpUnordered ||
         cmpResult == APFloat::cmpLessThan || cmpResult == APFloat::cmpEqual;
case arith::CmpFPredicate::UNE:
  return cmpResult != APFloat::cmpEqual;
case arith::CmpFPredicate::UNO:
  return cmpResult == APFloat::cmpUnordered;
case arith::CmpFPredicate::AlwaysTrue:
  return true;
}
llvm_unreachable("unknown cmpf predicate kind")::llvm::llvm_unreachable_internal("unknown cmpf predicate kind"
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 1405);
1406}

1408OpFoldResult arith::CmpFOp::fold(ArrayRef<Attribute> operands) {
assert(operands.size() == 2 && "cmpf takes two operands")(static_cast <bool> (operands.size() == 2 && "cmpf takes two operands"
) ? void (0) : __assert_fail ("operands.size() == 2 && \"cmpf takes two operands\""
, "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp", 1409, __extension__
 __PRETTY_FUNCTION__));

auto lhs = operands.front().dyn_cast_or_null<FloatAttr>();
auto rhs = operands.back().dyn_cast_or_null<FloatAttr>();

// If one operand is NaN, making them both NaN does not change the result.
if (lhs && lhs.getValue().isNaN())
  rhs = lhs;
if (rhs && rhs.getValue().isNaN())
  lhs = rhs;

if (!lhs || !rhs)
  return {};

auto val = applyCmpPredicate(getPredicate(), lhs.getValue(), rhs.getValue());
return BoolAttr::get(getContext(), val);
1425}

1427class CmpFIntToFPConst final : public OpRewritePattern<CmpFOp> {
1428public:
using OpRewritePattern<CmpFOp>::OpRewritePattern;

static CmpIPredicate convertToIntegerPredicate(CmpFPredicate pred,
                                               bool isUnsigned) {
  using namespace arith;
  switch (pred) {
  case CmpFPredicate::UEQ:
  case CmpFPredicate::OEQ:
    return CmpIPredicate::eq;
  case CmpFPredicate::UGT:
  case CmpFPredicate::OGT:
    return isUnsigned ? CmpIPredicate::ugt : CmpIPredicate::sgt;
  case CmpFPredicate::UGE:
  case CmpFPredicate::OGE:
    return isUnsigned ? CmpIPredicate::uge : CmpIPredicate::sge;
  case CmpFPredicate::ULT:
  case CmpFPredicate::OLT:
    return isUnsigned ? CmpIPredicate::ult : CmpIPredicate::slt;
  case CmpFPredicate::ULE:
  case CmpFPredicate::OLE:
    return isUnsigned ? CmpIPredicate::ule : CmpIPredicate::sle;
  case CmpFPredicate::UNE:
  case CmpFPredicate::ONE:
    return CmpIPredicate::ne;
  default:
    llvm_unreachable("Unexpected predicate!")::llvm::llvm_unreachable_internal("Unexpected predicate!", "mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp"
, 1454);
  }
}

LogicalResult matchAndRewrite(CmpFOp op,
                              PatternRewriter &rewriter) const override {
  FloatAttr flt;
  if (!matchPattern(op.getRhs(), m_Constant(&flt)))
    return failure();

  const APFloat &rhs = flt.getValue();

  // Don't attempt to fold a nan.
  if (rhs.isNaN())
    return failure();

  // Get the width of the mantissa.  We don't want to hack on conversions that
  // might lose information from the integer, e.g. "i64 -> float"
  FloatType floatTy = op.getRhs().getType().cast<FloatType>();
  int mantissaWidth = floatTy.getFPMantissaWidth();
  if (mantissaWidth <= 0)
    return failure();

  bool isUnsigned;
  Value intVal;

  if (auto si = op.getLhs().getDefiningOp<SIToFPOp>()) {
    isUnsigned = false;
    intVal = si.getIn();
  } else if (auto ui = op.getLhs().getDefiningOp<UIToFPOp>()) {
    isUnsigned = true;
    intVal = ui.getIn();
  } else {
    return failure();
  }

  // Check to see that the input is converted from an integer type that is
  // small enough that preserves all bits.
  auto intTy = intVal.getType().cast<IntegerType>();
  auto intWidth = intTy.getWidth();

  // Number of bits representing values, as opposed to the sign
  auto valueBits = isUnsigned ? intWidth : (intWidth - 1);

  // Following test does NOT adjust intWidth downwards for signed inputs,
  // because the most negative value still requires all the mantissa bits
  // to distinguish it from one less than that value.
  if ((int)intWidth > mantissaWidth) {
    // Conversion would lose accuracy. Check if loss can impact comparison.
    int exponent = ilogb(rhs);
    if (exponent == APFloat::IEK_Inf) {
      int maxExponent = ilogb(APFloat::getLargest(rhs.getSemantics()));
      if (maxExponent < (int)valueBits) {
        // Conversion could create infinity.
        return failure();
      }
    } else {
      // Note that if rhs is zero or NaN, then Exp is negative
      // and first condition is trivially false.
      if (mantissaWidth <= exponent && exponent <= (int)valueBits) {
        // Conversion could affect comparison.
        return failure();
      }
    }
  }

  // Convert to equivalent cmpi predicate
  CmpIPredicate pred;
  switch (op.getPredicate()) {
  case CmpFPredicate::ORD:
    // Int to fp conversion doesn't create a nan (ord checks neither is a nan)
    rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                               /*width=*/1);
    return success();
  case CmpFPredicate::UNO:
    // Int to fp conversion doesn't create a nan (uno checks either is a nan)
    rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                               /*width=*/1);
    return success();
  default:
    pred = convertToIntegerPredicate(op.getPredicate(), isUnsigned);
    break;
  }

  if (!isUnsigned) {
    // If the rhs value is > SignedMax, fold the comparison.  This handles
    // +INF and large values.
    APFloat signedMax(rhs.getSemantics());
    signedMax.convertFromAPInt(APInt::getSignedMaxValue(intWidth), true,
                               APFloat::rmNearestTiesToEven);
    if (signedMax < rhs) { // smax < 13123.0
      if (pred == CmpIPredicate::ne || pred == CmpIPredicate::slt ||
          pred == CmpIPredicate::sle)
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                                   /*width=*/1);
      else
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                                   /*width=*/1);
      return success();
    }
  } else {
    // If the rhs value is > UnsignedMax, fold the comparison. This handles
    // +INF and large values.
    APFloat unsignedMax(rhs.getSemantics());
    unsignedMax.convertFromAPInt(APInt::getMaxValue(intWidth), false,
                                 APFloat::rmNearestTiesToEven);
    if (unsignedMax < rhs) { // umax < 13123.0
      if (pred == CmpIPredicate::ne || pred == CmpIPredicate::ult ||
          pred == CmpIPredicate::ule)
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                                   /*width=*/1);
      else
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                                   /*width=*/1);
      return success();
    }
  }

  if (!isUnsigned) {
    // See if the rhs value is < SignedMin.
    APFloat signedMin(rhs.getSemantics());
    signedMin.convertFromAPInt(APInt::getSignedMinValue(intWidth), true,
                               APFloat::rmNearestTiesToEven);
    if (signedMin > rhs) { // smin > 12312.0
      if (pred == CmpIPredicate::ne || pred == CmpIPredicate::sgt ||
          pred == CmpIPredicate::sge)
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                                   /*width=*/1);
      else
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                                   /*width=*/1);
      return success();
    }
  } else {
    // See if the rhs value is < UnsignedMin.
    APFloat unsignedMin(rhs.getSemantics());
    unsignedMin.convertFromAPInt(APInt::getMinValue(intWidth), false,
                                 APFloat::rmNearestTiesToEven);
    if (unsignedMin > rhs) { // umin > 12312.0
      if (pred == CmpIPredicate::ne || pred == CmpIPredicate::ugt ||
          pred == CmpIPredicate::uge)
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                                   /*width=*/1);
      else
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                                   /*width=*/1);
      return success();
    }
  }

  // Okay, now we know that the FP constant fits in the range [SMIN, SMAX] or
  // [0, UMAX], but it may still be fractional.  See if it is fractional by
  // casting the FP value to the integer value and back, checking for
  // equality. Don't do this for zero, because -0.0 is not fractional.
  bool ignored;
  APSInt rhsInt(intWidth, isUnsigned);
  if (APFloat::opInvalidOp ==
      rhs.convertToInteger(rhsInt, APFloat::rmTowardZero, &ignored)) {
    // Undefined behavior invoked - the destination type can't represent
    // the input constant.
    return failure();
  }

  if (!rhs.isZero()) {
    APFloat apf(floatTy.getFloatSemantics(),
                APInt::getZero(floatTy.getWidth()));
    apf.convertFromAPInt(rhsInt, !isUnsigned, APFloat::rmNearestTiesToEven);

    bool equal = apf == rhs;
    if (!equal) {
      // If we had a comparison against a fractional value, we have to adjust
      // the compare predicate and sometimes the value.  rhsInt is rounded
      // towards zero at this point.
      switch (pred) {
      case CmpIPredicate::ne: // (float)int != 4.4   --> true
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                                   /*width=*/1);
        return success();
      case CmpIPredicate::eq: // (float)int == 4.4   --> false
        rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                                   /*width=*/1);
        return success();
      case CmpIPredicate::ule:
        // (float)int <= 4.4   --> int <= 4
        // (float)int <= -4.4  --> false
        if (rhs.isNegative()) {
          rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                                     /*width=*/1);
          return success();
        }
        break;
      case CmpIPredicate::sle:
        // (float)int <= 4.4   --> int <= 4
        // (float)int <= -4.4  --> int < -4
        if (rhs.isNegative())
          pred = CmpIPredicate::slt;
        break;
      case CmpIPredicate::ult:
        // (float)int < -4.4   --> false
        // (float)int < 4.4    --> int <= 4
        if (rhs.isNegative()) {
          rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/false,
                                                     /*width=*/1);
          return success();
        }
        pred = CmpIPredicate::ule;
        break;
      case CmpIPredicate::slt:
        // (float)int < -4.4   --> int < -4
        // (float)int < 4.4    --> int <= 4
        if (!rhs.isNegative())
          pred = CmpIPredicate::sle;
        break;
      case CmpIPredicate::ugt:
        // (float)int > 4.4    --> int > 4
        // (float)int > -4.4   --> true
        if (rhs.isNegative()) {
          rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                                     /*width=*/1);
          return success();
        }
        break;
      case CmpIPredicate::sgt:
        // (float)int > 4.4    --> int > 4
        // (float)int > -4.4   --> int >= -4
        if (rhs.isNegative())
          pred = CmpIPredicate::sge;
        break;
      case CmpIPredicate::uge:
        // (float)int >= -4.4   --> true
        // (float)int >= 4.4    --> int > 4
        if (rhs.isNegative()) {
          rewriter.replaceOpWithNewOp<ConstantIntOp>(op, /*value=*/true,
                                                     /*width=*/1);
          return success();
        }
        pred = CmpIPredicate::ugt;
        break;
      case CmpIPredicate::sge:
        // (float)int >= -4.4   --> int >= -4
        // (float)int >= 4.4    --> int > 4
        if (!rhs.isNegative())
          pred = CmpIPredicate::sgt;
        break;
      }
    }
  }

  // Lower this FP comparison into an appropriate integer version of the
  // comparison.
  rewriter.replaceOpWithNewOp<CmpIOp>(
      op, pred, intVal,
      rewriter.create<ConstantOp>(
          op.getLoc(), intVal.getType(),
          rewriter.getIntegerAttr(intVal.getType(), rhsInt)));
  return success();
}
1711};

1713void arith::CmpFOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                              MLIRContext *context) {
patterns.insert<CmpFIntToFPConst>(context);
1716}

1718//===----------------------------------------------------------------------===//
1719// SelectOp
1720//===----------------------------------------------------------------------===//

1722// Transforms a select of a boolean to arithmetic operations
1723//
1724//  arith.select %arg, %x, %y : i1
1725//
1726//  becomes
1727//
1728//  and(%arg, %x) or and(!%arg, %y)
1729struct SelectI1Simplify : public OpRewritePattern<arith::SelectOp> {
using OpRewritePattern<arith::SelectOp>::OpRewritePattern;

LogicalResult matchAndRewrite(arith::SelectOp op,
                              PatternRewriter &rewriter) const override {
  if (!op.getType().isInteger(1))
    return failure();

  Value falseConstant =
      rewriter.create<arith::ConstantIntOp>(op.getLoc(), true, 1);
  Value notCondition = rewriter.create<arith::XOrIOp>(
      op.getLoc(), op.getCondition(), falseConstant);

  Value trueVal = rewriter.create<arith::AndIOp>(
      op.getLoc(), op.getCondition(), op.getTrueValue());
  Value falseVal = rewriter.create<arith::AndIOp>(op.getLoc(), notCondition,
                                                  op.getFalseValue());
  rewriter.replaceOpWithNewOp<arith::OrIOp>(op, trueVal, falseVal);
  return success();
}
1749};

1751//  select %arg, %c1, %c0 => extui %arg
1752struct SelectToExtUI : public OpRewritePattern<arith::SelectOp> {
using OpRewritePattern<arith::SelectOp>::OpRewritePattern;

LogicalResult matchAndRewrite(arith::SelectOp op,
                              PatternRewriter &rewriter) const override {
  // Cannot extui i1 to i1, or i1 to f32
  if (!op.getType().isa<IntegerType>() || op.getType().isInteger(1))
    return failure();

  // select %x, c1, %c0 => extui %arg
  if (matchPattern(op.getTrueValue(), m_One()))
    if (matchPattern(op.getFalseValue(), m_Zero())) {
      rewriter.replaceOpWithNewOp<arith::ExtUIOp>(op, op.getType(),
                                                  op.getCondition());
      return success();
    }

  // select %x, c0, %c1 => extui (xor %arg, true)
  if (matchPattern(op.getTrueValue(), m_Zero()))
    if (matchPattern(op.getFalseValue(), m_One())) {
      rewriter.replaceOpWithNewOp<arith::ExtUIOp>(
          op, op.getType(),
          rewriter.create<arith::XOrIOp>(
              op.getLoc(), op.getCondition(),
              rewriter.create<arith::ConstantIntOp>(
                  op.getLoc(), 1, op.getCondition().getType())));
      return success();
    }

  return failure();
}
1783};

1785void arith::SelectOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
results.add<SelectI1Simplify, SelectToExtUI>(context);
1788}

1790OpFoldResult arith::SelectOp::fold(ArrayRef<Attribute> operands) {
Value trueVal = getTrueValue();
Value falseVal = getFalseValue();
if (trueVal == falseVal)
  return trueVal;

Value condition = getCondition();

// select true, %0, %1 => %0
if (matchPattern(condition, m_One()))
  return trueVal;

// select false, %0, %1 => %1
if (matchPattern(condition, m_Zero()))
  return falseVal;

// select %x, true, false => %x
if (getType().isInteger(1))
  if (matchPattern(getTrueValue(), m_One()))
    if (matchPattern(getFalseValue(), m_Zero()))
      return condition;

if (auto cmp = dyn_cast_or_null<arith::CmpIOp>(condition.getDefiningOp())) {
  auto pred = cmp.getPredicate();
  if (pred == arith::CmpIPredicate::eq || pred == arith::CmpIPredicate::ne) {
    auto cmpLhs = cmp.getLhs();
    auto cmpRhs = cmp.getRhs();

    // %0 = arith.cmpi eq, %arg0, %arg1
    // %1 = arith.select %0, %arg0, %arg1 => %arg1

    // %0 = arith.cmpi ne, %arg0, %arg1
    // %1 = arith.select %0, %arg0, %arg1 => %arg0

    if ((cmpLhs == trueVal && cmpRhs == falseVal) ||
        (cmpRhs == trueVal && cmpLhs == falseVal))
      return pred == arith::CmpIPredicate::ne ? trueVal : falseVal;
  }
}
return nullptr;
1830}

1832ParseResult SelectOp::parse(OpAsmParser &parser, OperationState &result) {
Type conditionType, resultType;
SmallVector<OpAsmParser::UnresolvedOperand, 3> operands;
if (parser.parseOperandList(operands, /*requiredOperandCount=*/3) ||
    parser.parseOptionalAttrDict(result.attributes) ||
    parser.parseColonType(resultType))
  return failure();

// Check for the explicit condition type if this is a masked tensor or vector.
if (succeeded(parser.parseOptionalComma())) {
  conditionType = resultType;
  if (parser.parseType(resultType))
    return failure();
} else {
  conditionType = parser.getBuilder().getI1Type();
}

result.addTypes(resultType);
return parser.resolveOperands(operands,
                              {conditionType, resultType, resultType},
                              parser.getNameLoc(), result.operands);
1853}

1855void arith::SelectOp::print(OpAsmPrinter &p) {
p << " " << getOperands();
p.printOptionalAttrDict((*this)->getAttrs());
p << " : ";
if (ShapedType condType = getCondition().getType().dyn_cast<ShapedType>())
  p << condType << ", ";
p << getType();
1862}

1864LogicalResult arith::SelectOp::verify() {
Type conditionType = getCondition().getType();
if (conditionType.isSignlessInteger(1))
  return success();

// If the result type is a vector or tensor, the type can be a mask with the
// same elements.
Type resultType = getType();
if (!resultType.isa<TensorType, VectorType>())
  return emitOpError() << "expected condition to be a signless i1, but got "
                       << conditionType;
Type shapedConditionType = getI1SameShape(resultType);
if (conditionType != shapedConditionType) {
  return emitOpError() << "expected condition type to have the same shape "
                          "as the result type, expected "
                       << shapedConditionType << ", but got "
                       << conditionType;
}
return success();
1883}
1884//===----------------------------------------------------------------------===//
1885// ShLIOp
1886//===----------------------------------------------------------------------===//

1888OpFoldResult arith::ShLIOp::fold(ArrayRef<Attribute> operands) {
// Don't fold if shifting more than the bit width.
bool bounded = false;
auto result = constFoldBinaryOp<IntegerAttr>(
    operands, [&](const APInt &a, const APInt &b) {
      bounded = b.ule(b.getBitWidth());
      return a.shl(b);
    });
return bounded ? result : Attribute();
1897}

1899//===----------------------------------------------------------------------===//
1900// ShRUIOp
1901//===----------------------------------------------------------------------===//

1903OpFoldResult arith::ShRUIOp::fold(ArrayRef<Attribute> operands) {
// Don't fold if shifting more than the bit width.
bool bounded = false;
auto result = constFoldBinaryOp<IntegerAttr>(
    operands, [&](const APInt &a, const APInt &b) {
      bounded = b.ule(b.getBitWidth());
      return a.lshr(b);
    });
return bounded ? result : Attribute();
1912}

1914//===----------------------------------------------------------------------===//
1915// ShRSIOp
1916//===----------------------------------------------------------------------===//

1918OpFoldResult arith::ShRSIOp::fold(ArrayRef<Attribute> operands) {
// Don't fold if shifting more than the bit width.
bool bounded = false;
auto result = constFoldBinaryOp<IntegerAttr>(
    operands, [&](const APInt &a, const APInt &b) {
      bounded = b.ule(b.getBitWidth());
      return a.ashr(b);
    });
return bounded ? result : Attribute();
1927}

1929//===----------------------------------------------------------------------===//
1930// Atomic Enum
1931//===----------------------------------------------------------------------===//

1933/// Returns the identity value attribute associated with an AtomicRMWKind op.
1934Attribute mlir::arith::getIdentityValueAttr(AtomicRMWKind kind, Type resultType,
                                          OpBuilder &builder, Location loc) {
switch (kind) {
case AtomicRMWKind::maxf:
  return builder.getFloatAttr(
      resultType,
      APFloat::getInf(resultType.cast<FloatType>().getFloatSemantics(),
                      /*Negative=*/true));
case AtomicRMWKind::addf:
case AtomicRMWKind::addi:
case AtomicRMWKind::maxu:
case AtomicRMWKind::ori:
  return builder.getZeroAttr(resultType);
case AtomicRMWKind::andi:
  return builder.getIntegerAttr(
      resultType,
      APInt::getAllOnes(resultType.cast<IntegerType>().getWidth()));
case AtomicRMWKind::maxs:
  return builder.getIntegerAttr(
      resultType,
      APInt::getSignedMinValue(resultType.cast<IntegerType>().getWidth()));
case AtomicRMWKind::minf:
  return builder.getFloatAttr(
      resultType,
      APFloat::getInf(resultType.cast<FloatType>().getFloatSemantics(),
                      /*Negative=*/false));
case AtomicRMWKind::mins:
  return builder.getIntegerAttr(
      resultType,
      APInt::getSignedMaxValue(resultType.cast<IntegerType>().getWidth()));
case AtomicRMWKind::minu:
  return builder.getIntegerAttr(
      resultType,
      APInt::getMaxValue(resultType.cast<IntegerType>().getWidth()));
case AtomicRMWKind::muli:
  return builder.getIntegerAttr(resultType, 1);
case AtomicRMWKind::mulf:
  return builder.getFloatAttr(resultType, 1);
// TODO: Add remaining reduction operations.
default:
  (void)emitOptionalError(loc, "Reduction operation type not supported");
  break;
}
return nullptr;
1978}

1980/// Returns the identity value associated with an AtomicRMWKind op.
1981Value mlir::arith::getIdentityValue(AtomicRMWKind op, Type resultType,
                                  OpBuilder &builder, Location loc) {
Attribute attr = getIdentityValueAttr(op, resultType, builder, loc);
return builder.create<arith::ConstantOp>(loc, attr);
1
Calling 'OpBuilder::create'→
1985}

1987/// Return the value obtained by applying the reduction operation kind
1988/// associated with a binary AtomicRMWKind op to `lhs` and `rhs`.
1989Value mlir::arith::getReductionOp(AtomicRMWKind op, OpBuilder &builder,
                                Location loc, Value lhs, Value rhs) {
switch (op) {
case AtomicRMWKind::addf:
  return builder.create<arith::AddFOp>(loc, lhs, rhs);
case AtomicRMWKind::addi:
  return builder.create<arith::AddIOp>(loc, lhs, rhs);
case AtomicRMWKind::mulf:
  return builder.create<arith::MulFOp>(loc, lhs, rhs);
case AtomicRMWKind::muli:
  return builder.create<arith::MulIOp>(loc, lhs, rhs);
case AtomicRMWKind::maxf:
  return builder.create<arith::MaxFOp>(loc, lhs, rhs);
case AtomicRMWKind::minf:
  return builder.create<arith::MinFOp>(loc, lhs, rhs);
case AtomicRMWKind::maxs:
  return builder.create<arith::MaxSIOp>(loc, lhs, rhs);
case AtomicRMWKind::mins:
  return builder.create<arith::MinSIOp>(loc, lhs, rhs);
case AtomicRMWKind::maxu:
  return builder.create<arith::MaxUIOp>(loc, lhs, rhs);
case AtomicRMWKind::minu:
  return builder.create<arith::MinUIOp>(loc, lhs, rhs);
case AtomicRMWKind::ori:
  return builder.create<arith::OrIOp>(loc, lhs, rhs);
case AtomicRMWKind::andi:
  return builder.create<arith::AndIOp>(loc, lhs, rhs);
// TODO: Add remaining reduction operations.
default:
  (void)emitOptionalError(loc, "Reduction operation type not supported");
  break;
}
return nullptr;
2022}

2024//===----------------------------------------------------------------------===//
2025// TableGen'd op method definitions
2026//===----------------------------------------------------------------------===//

2028#define GET_OP_CLASSES
2029#include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"

2031//===----------------------------------------------------------------------===//
2032// TableGen'd enum attribute definitions
2033//===----------------------------------------------------------------------===//

2035#include "mlir/Dialect/Arithmetic/IR/ArithmeticOpsEnums.cpp.inc"

←

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/include/mlir/IR/Builders.h

→

1//===- Builders.h - Helpers for constructing MLIR Classes -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#ifndef MLIR_IR_BUILDERS_H
10#define MLIR_IR_BUILDERS_H

12#include "mlir/IR/OpDefinition.h"
13#include "llvm/Support/Compiler.h"

15namespace mlir {

17class AffineExpr;
18class BlockAndValueMapping;
19class UnknownLoc;
20class FileLineColLoc;
21class Type;
22class PrimitiveType;
23class IntegerType;
24class FloatType;
25class FunctionType;
26class IndexType;
27class MemRefType;
28class VectorType;
29class RankedTensorType;
30class UnrankedTensorType;
31class TupleType;
32class NoneType;
33class BoolAttr;
34class IntegerAttr;
35class FloatAttr;
36class StringAttr;
37class TypeAttr;
38class ArrayAttr;
39class SymbolRefAttr;
40class ElementsAttr;
41class DenseElementsAttr;
42class DenseIntElementsAttr;
43class AffineMapAttr;
44class AffineMap;
45class UnitAttr;

47/// This class is a general helper class for creating context-global objects
48/// like types, attributes, and affine expressions.
49class Builder {
50public:
explicit Builder(MLIRContext *context) : context(context) {}
explicit Builder(Operation *op) : Builder(op->getContext()) {}

MLIRContext *getContext() const { return context; }

// Locations.
Location getUnknownLoc();
Location getFusedLoc(ArrayRef<Location> locs,
                     Attribute metadata = Attribute());

// Types.
FloatType getBF16Type();
FloatType getF16Type();
FloatType getF32Type();
FloatType getF64Type();
FloatType getF80Type();
FloatType getF128Type();

IndexType getIndexType();

IntegerType getI1Type();
IntegerType getI8Type();
IntegerType getI32Type();
IntegerType getI64Type();
IntegerType getIntegerType(unsigned width);
IntegerType getIntegerType(unsigned width, bool isSigned);
FunctionType getFunctionType(TypeRange inputs, TypeRange results);
TupleType getTupleType(TypeRange elementTypes);
NoneType getNoneType();

/// Get or construct an instance of the type 'ty' with provided arguments.
template <typename Ty, typename... Args>
Ty getType(Args... args) {
  return Ty::get(context, args...);
}

// Attributes.
NamedAttribute getNamedAttr(StringRef name, Attribute val);

UnitAttr getUnitAttr();
BoolAttr getBoolAttr(bool value);
DictionaryAttr getDictionaryAttr(ArrayRef<NamedAttribute> value);
IntegerAttr getIntegerAttr(Type type, int64_t value);
IntegerAttr getIntegerAttr(Type type, const APInt &value);
FloatAttr getFloatAttr(Type type, double value);
FloatAttr getFloatAttr(Type type, const APFloat &value);
StringAttr getStringAttr(const Twine &bytes);
ArrayAttr getArrayAttr(ArrayRef<Attribute> value);

// Returns a 0-valued attribute of the given `type`. This function only
// supports boolean, integer, and 16-/32-/64-bit float types, and vector or
// ranked tensor of them. Returns null attribute otherwise.
Attribute getZeroAttr(Type type);

// Convenience methods for fixed types.
FloatAttr getF16FloatAttr(float value);
FloatAttr getF32FloatAttr(float value);
FloatAttr getF64FloatAttr(double value);

IntegerAttr getI8IntegerAttr(int8_t value);
IntegerAttr getI16IntegerAttr(int16_t value);
IntegerAttr getI32IntegerAttr(int32_t value);
IntegerAttr getI64IntegerAttr(int64_t value);
IntegerAttr getIndexAttr(int64_t value);

/// Signed and unsigned integer attribute getters.
IntegerAttr getSI32IntegerAttr(int32_t value);
IntegerAttr getUI32IntegerAttr(uint32_t value);

/// Vector-typed DenseIntElementsAttr getters. `values` must not be empty.
DenseIntElementsAttr getBoolVectorAttr(ArrayRef<bool> values);
DenseIntElementsAttr getI32VectorAttr(ArrayRef<int32_t> values);
DenseIntElementsAttr getI64VectorAttr(ArrayRef<int64_t> values);
DenseIntElementsAttr getIndexVectorAttr(ArrayRef<int64_t> values);

/// Tensor-typed DenseIntElementsAttr getters. `values` can be empty.
/// These are generally preferable for representing general lists of integers
/// as attributes.
DenseIntElementsAttr getI32TensorAttr(ArrayRef<int32_t> values);
DenseIntElementsAttr getI64TensorAttr(ArrayRef<int64_t> values);
DenseIntElementsAttr getIndexTensorAttr(ArrayRef<int64_t> values);

ArrayAttr getAffineMapArrayAttr(ArrayRef<AffineMap> values);
ArrayAttr getBoolArrayAttr(ArrayRef<bool> values);
ArrayAttr getI32ArrayAttr(ArrayRef<int32_t> values);
ArrayAttr getI64ArrayAttr(ArrayRef<int64_t> values);
ArrayAttr getIndexArrayAttr(ArrayRef<int64_t> values);
ArrayAttr getF32ArrayAttr(ArrayRef<float> values);
ArrayAttr getF64ArrayAttr(ArrayRef<double> values);
ArrayAttr getStrArrayAttr(ArrayRef<StringRef> values);
ArrayAttr getTypeArrayAttr(TypeRange values);

// Affine expressions and affine maps.
AffineExpr getAffineDimExpr(unsigned position);
AffineExpr getAffineSymbolExpr(unsigned position);
AffineExpr getAffineConstantExpr(int64_t constant);

// Special cases of affine maps and integer sets
/// Returns a zero result affine map with no dimensions or symbols: () -> ().
AffineMap getEmptyAffineMap();
/// Returns a single constant result affine map with 0 dimensions and 0
/// symbols.  One constant result: () -> (val).
AffineMap getConstantAffineMap(int64_t val);
// One dimension id identity map: (i) -> (i).
AffineMap getDimIdentityMap();
// Multi-dimensional identity map: (d0, d1, d2) -> (d0, d1, d2).
AffineMap getMultiDimIdentityMap(unsigned rank);
// One symbol identity map: ()[s] -> (s).
AffineMap getSymbolIdentityMap();

/// Returns a map that shifts its (single) input dimension by 'shift'.
/// (d0) -> (d0 + shift)
AffineMap getSingleDimShiftAffineMap(int64_t shift);

/// Returns an affine map that is a translation (shift) of all result
/// expressions in 'map' by 'shift'.
/// Eg: input: (d0, d1)[s0] -> (d0, d1 + s0), shift = 2
///   returns:    (d0, d1)[s0] -> (d0 + 2, d1 + s0 + 2)
AffineMap getShiftedAffineMap(AffineMap map, int64_t shift);

171protected:
MLIRContext *context;
173};

175/// This class helps build Operations. Operations that are created are
176/// automatically inserted at an insertion point. The builder is copyable.
177class OpBuilder : public Builder {
178public:
struct Listener;

/// Create a builder with the given context.
explicit OpBuilder(MLIRContext *ctx, Listener *listener = nullptr)
    : Builder(ctx), listener(listener) {}

/// Create a builder and set the insertion point to the start of the region.
explicit OpBuilder(Region *region, Listener *listener = nullptr)
    : OpBuilder(region->getContext(), listener) {
  if (!region->empty())
    setInsertionPoint(&region->front(), region->front().begin());
}
explicit OpBuilder(Region &region, Listener *listener = nullptr)
    : OpBuilder(&region, listener) {}

/// Create a builder and set insertion point to the given operation, which
/// will cause subsequent insertions to go right before it.
explicit OpBuilder(Operation *op, Listener *listener = nullptr)
    : OpBuilder(op->getContext(), listener) {
  setInsertionPoint(op);
}

OpBuilder(Block *block, Block::iterator insertPoint,
          Listener *listener = nullptr)
    : OpBuilder(block->getParent()->getContext(), listener) {
  setInsertionPoint(block, insertPoint);
}

/// Create a builder and set the insertion point to before the first operation
/// in the block but still inside the block.
static OpBuilder atBlockBegin(Block *block, Listener *listener = nullptr) {
  return OpBuilder(block, block->begin(), listener);
}

/// Create a builder and set the insertion point to after the last operation
/// in the block but still inside the block.
static OpBuilder atBlockEnd(Block *block, Listener *listener = nullptr) {
  return OpBuilder(block, block->end(), listener);
}

/// Create a builder and set the insertion point to before the block
/// terminator.
static OpBuilder atBlockTerminator(Block *block,
                                   Listener *listener = nullptr) {
  auto *terminator = block->getTerminator();
  assert(terminator != nullptr && "the block has no terminator")(static_cast <bool> (terminator != nullptr && "the block has no terminator"
) ? void (0) : __assert_fail ("terminator != nullptr && \"the block has no terminator\""
, "mlir/include/mlir/IR/Builders.h", 224, __extension__ __PRETTY_FUNCTION__
));
  return OpBuilder(block, Block::iterator(terminator), listener);
}

//===--------------------------------------------------------------------===//
// Listeners
//===--------------------------------------------------------------------===//

/// This class represents a listener that may be used to hook into various
/// actions within an OpBuilder.
struct Listener {
  virtual ~Listener();

  /// Notification handler for when an operation is inserted into the builder.
  /// `op` is the operation that was inserted.
  virtual void notifyOperationInserted(Operation *op) {}

  /// Notification handler for when a block is created using the builder.
  /// `block` is the block that was created.
  virtual void notifyBlockCreated(Block *block) {}
};

/// Sets the listener of this builder to the one provided.
void setListener(Listener *newListener) { listener = newListener; }

/// Returns the current listener of this builder, or nullptr if this builder
/// doesn't have a listener.
Listener *getListener() const { return listener; }

//===--------------------------------------------------------------------===//
// Insertion Point Management
//===--------------------------------------------------------------------===//

/// This class represents a saved insertion point.
class InsertPoint {
public:
  /// Creates a new insertion point which doesn't point to anything.
  InsertPoint() = default;

  /// Creates a new insertion point at the given location.
  InsertPoint(Block *insertBlock, Block::iterator insertPt)
      : block(insertBlock), point(insertPt) {}

  /// Returns true if this insert point is set.
  bool isSet() const { return (block != nullptr); }

  Block *getBlock() const { return block; }
  Block::iterator getPoint() const { return point; }

private:
  Block *block = nullptr;
  Block::iterator point;
};

/// RAII guard to reset the insertion point of the builder when destroyed.
class InsertionGuard {
public:
  InsertionGuard(OpBuilder &builder)
      : builder(&builder), ip(builder.saveInsertionPoint()) {}

  ~InsertionGuard() {
    if (builder)
      builder->restoreInsertionPoint(ip);
  }

  InsertionGuard(const InsertionGuard &) = delete;
  InsertionGuard &operator=(const InsertionGuard &) = delete;

  /// Implement the move constructor to clear the builder field of `other`.
  /// That way it does not restore the insertion point upon destruction as
  /// that should be done exclusively by the just constructed InsertionGuard.
  InsertionGuard(InsertionGuard &&other) noexcept
      : builder(other.builder), ip(other.ip) {
    other.builder = nullptr;
  }

  InsertionGuard &operator=(InsertionGuard &&other) = delete;

private:
  OpBuilder *builder;
  OpBuilder::InsertPoint ip;
};

/// Reset the insertion point to no location.  Creating an operation without a
/// set insertion point is an error, but this can still be useful when the
/// current insertion point a builder refers to is being removed.
void clearInsertionPoint() {
  this->block = nullptr;
  insertPoint = Block::iterator();
}

/// Return a saved insertion point.
InsertPoint saveInsertionPoint() const {
  return InsertPoint(getInsertionBlock(), getInsertionPoint());
}

/// Restore the insert point to a previously saved point.
void restoreInsertionPoint(InsertPoint ip) {
  if (ip.isSet())
    setInsertionPoint(ip.getBlock(), ip.getPoint());
  else
    clearInsertionPoint();
}

/// Set the insertion point to the specified location.
void setInsertionPoint(Block *block, Block::iterator insertPoint) {
  // TODO: check that insertPoint is in this rather than some other block.
  this->block = block;
  this->insertPoint = insertPoint;
}

/// Sets the insertion point to the specified operation, which will cause
/// subsequent insertions to go right before it.
void setInsertionPoint(Operation *op) {
  setInsertionPoint(op->getBlock(), Block::iterator(op));
}

/// Sets the insertion point to the node after the specified operation, which
/// will cause subsequent insertions to go right after it.
void setInsertionPointAfter(Operation *op) {
  setInsertionPoint(op->getBlock(), ++Block::iterator(op));
}

/// Sets the insertion point to the node after the specified value. If value
/// has a defining operation, sets the insertion point to the node after such
/// defining operation. This will cause subsequent insertions to go right
/// after it. Otherwise, value is a BlockArgument. Sets the insertion point to
/// the start of its block.
void setInsertionPointAfterValue(Value val) {
  if (Operation *op = val.getDefiningOp()) {
    setInsertionPointAfter(op);
  } else {
    auto blockArg = val.cast<BlockArgument>();
    setInsertionPointToStart(blockArg.getOwner());
  }
}

/// Sets the insertion point to the start of the specified block.
void setInsertionPointToStart(Block *block) {
  setInsertionPoint(block, block->begin());
}

/// Sets the insertion point to the end of the specified block.
void setInsertionPointToEnd(Block *block) {
  setInsertionPoint(block, block->end());
}

/// Return the block the current insertion point belongs to.  Note that the
/// the insertion point is not necessarily the end of the block.
Block *getInsertionBlock() const { return block; }

/// Returns the current insertion point of the builder.
Block::iterator getInsertionPoint() const { return insertPoint; }

/// Returns the current block of the builder.
Block *getBlock() const { return block; }

//===--------------------------------------------------------------------===//
// Block Creation
//===--------------------------------------------------------------------===//

/// Add new block with 'argTypes' arguments and set the insertion point to the
/// end of it. The block is inserted at the provided insertion point of
/// 'parent'. `locs` contains the locations of the inserted arguments, and
/// should match the size of `argTypes`.
Block *createBlock(Region *parent, Region::iterator insertPt = {},
                   TypeRange argTypes = llvm::None,
                   ArrayRef<Location> locs = llvm::None);

/// Add new block with 'argTypes' arguments and set the insertion point to the
/// end of it. The block is placed before 'insertBefore'. `locs` contains the
/// locations of the inserted arguments, and should match the size of
/// `argTypes`.
Block *createBlock(Block *insertBefore, TypeRange argTypes = llvm::None,
                   ArrayRef<Location> locs = llvm::None);

//===--------------------------------------------------------------------===//
// Operation Creation
//===--------------------------------------------------------------------===//

/// Insert the given operation at the current insertion point and return it.
Operation *insert(Operation *op);

/// Creates an operation given the fields represented as an OperationState.
Operation *create(const OperationState &state);

/// Creates an operation with the given fields.
Operation *create(Location loc, StringAttr opName, ValueRange operands,
                  TypeRange types = {},
                  ArrayRef<NamedAttribute> attributes = {},
                  BlockRange successors = {},
                  MutableArrayRef<std::unique_ptr<Region>> regions = {});

417private:
/// Helper for sanity checking preconditions for create* methods below.
template <typename OpT>
RegisteredOperationName getCheckRegisteredInfo(MLIRContext *ctx) {
  Optional<RegisteredOperationName> opName =
      RegisteredOperationName::lookup(OpT::getOperationName(), ctx);
  if (LLVM_UNLIKELY(!opName)__builtin_expect((bool)(!opName), false)) {
    llvm::report_fatal_error(
        "Building op `" + OpT::getOperationName() +
        "` but it isn't registered in this MLIRContext: the dialect may not "
        "be loaded or this operation isn't registered by the dialect. See "
        "also https://mlir.llvm.org/getting_started/Faq/"
        "#registered-loaded-dependent-whats-up-with-dialects-management");
  }
  return *opName;
}

434public:
/// Create an operation of specific op type at the current insertion point.
template <typename OpTy, typename... Args>
OpTy create(Location location, Args &&...args) {
  OperationState state(location,
                       getCheckRegisteredInfo<OpTy>(location.getContext()));
  OpTy::build(*this, state, std::forward<Args>(args)...);
2
←
Null pointer value stored to 'value.impl'→
3
←
Calling 'ConstantOp::build'→
  auto *op = create(state);
  auto result = dyn_cast<OpTy>(op);
  assert(result && "builder didn't return the right type")(static_cast <bool> (result && "builder didn't return the right type"
) ? void (0) : __assert_fail ("result && \"builder didn't return the right type\""
, "mlir/include/mlir/IR/Builders.h", 443, __extension__ __PRETTY_FUNCTION__
));
  return result;
}

/// Create an operation of specific op type at the current insertion point,
/// and immediately try to fold it. This functions populates 'results' with
/// the results after folding the operation.
template <typename OpTy, typename... Args>
void createOrFold(SmallVectorImpl<Value> &results, Location location,
                  Args &&...args) {
  // Create the operation without using 'create' as we don't want to
  // insert it yet.
  OperationState state(location,
                       getCheckRegisteredInfo<OpTy>(location.getContext()));
  OpTy::build(*this, state, std::forward<Args>(args)...);
  Operation *op = Operation::create(state);

  // Fold the operation. If successful destroy it, otherwise insert it.
  if (succeeded(tryFold(op, results)))
    op->destroy();
  else
    insert(op);
}

/// Overload to create or fold a single result operation.
template <typename OpTy, typename... Args>
typename std::enable_if<OpTy::template hasTrait<OpTrait::OneResult>(),
                        Value>::type
createOrFold(Location location, Args &&...args) {
  SmallVector<Value, 1> results;
  createOrFold<OpTy>(results, location, std::forward<Args>(args)...);
  return results.front();
}

/// Overload to create or fold a zero result operation.
template <typename OpTy, typename... Args>
typename std::enable_if<OpTy::template hasTrait<OpTrait::ZeroResult>(),
                        OpTy>::type
createOrFold(Location location, Args &&...args) {
  auto op = create<OpTy>(location, std::forward<Args>(args)...);
  SmallVector<Value, 0> unused;
  (void)tryFold(op.getOperation(), unused);

  // Folding cannot remove a zero-result operation, so for convenience we
  // continue to return it.
  return op;
}

/// Attempts to fold the given operation and places new results within
/// 'results'. Returns success if the operation was folded, failure otherwise.
/// Note: This function does not erase the operation on a successful fold.
LogicalResult tryFold(Operation *op, SmallVectorImpl<Value> &results);

/// Creates a deep copy of the specified operation, remapping any operands
/// that use values outside of the operation using the map that is provided
/// ( leaving them alone if no entry is present).  Replaces references to
/// cloned sub-operations to the corresponding operation that is copied,
/// and adds those mappings to the map.
Operation *clone(Operation &op, BlockAndValueMapping &mapper);
Operation *clone(Operation &op);

/// Creates a deep copy of this operation but keep the operation regions
/// empty. Operands are remapped using `mapper` (if present), and `mapper` is
/// updated to contain the results.
Operation *cloneWithoutRegions(Operation &op, BlockAndValueMapping &mapper) {
  return insert(op.cloneWithoutRegions(mapper));
}
Operation *cloneWithoutRegions(Operation &op) {
  return insert(op.cloneWithoutRegions());
}
template <typename OpT>
OpT cloneWithoutRegions(OpT op) {
  return cast<OpT>(cloneWithoutRegions(*op.getOperation()));
}

518private:
/// The current block this builder is inserting into.
Block *block = nullptr;
/// The insertion point within the block that this builder is inserting
/// before.
Block::iterator insertPoint;
/// The optional listener for events of this builder.
Listener *listener;
526};

528} // namespace mlir

530#endif

←

tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc

→

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
*                                                                            *|
* Op Definitions                                                             *|
*                                                                            *|
* Automatically generated file, do not edit!                                 *|
*                                                                            *|
7\*===----------------------------------------------------------------------===*/

9#ifdef GET_OP_LIST
10#undef GET_OP_LIST

:mlir::arith::AddFOp,
:mlir::arith::AddIOp,
:mlir::arith::AndIOp,
:mlir::arith::BitcastOp,
:mlir::arith::CeilDivSIOp,
:mlir::arith::CeilDivUIOp,
:mlir::arith::CmpFOp,
:mlir::arith::CmpIOp,
:mlir::arith::ConstantOp,
:mlir::arith::DivFOp,
:mlir::arith::DivSIOp,
:mlir::arith::DivUIOp,
:mlir::arith::ExtFOp,
:mlir::arith::ExtSIOp,
:mlir::arith::ExtUIOp,
:mlir::arith::FPToSIOp,
:mlir::arith::FPToUIOp,
:mlir::arith::FloorDivSIOp,
:mlir::arith::IndexCastOp,
:mlir::arith::MaxFOp,
:mlir::arith::MaxSIOp,
:mlir::arith::MaxUIOp,
:mlir::arith::MinFOp,
:mlir::arith::MinSIOp,
:mlir::arith::MinUIOp,
:mlir::arith::MulFOp,
:mlir::arith::MulIOp,
:mlir::arith::NegFOp,
:mlir::arith::OrIOp,
:mlir::arith::RemFOp,
:mlir::arith::RemSIOp,
:mlir::arith::RemUIOp,
:mlir::arith::SIToFPOp,
:mlir::arith::ShLIOp,
:mlir::arith::ShRSIOp,
:mlir::arith::ShRUIOp,
:mlir::arith::SubFOp,
:mlir::arith::SubIOp,
:mlir::arith::TruncFOp,
:mlir::arith::TruncIOp,
:mlir::arith::UIToFPOp,
:mlir::arith::XOrIOp,
:mlir::arith::SelectOp
55#endif  // GET_OP_LIST

57#ifdef GET_OP_CLASSES
58#undef GET_OP_CLASSES


61//===----------------------------------------------------------------------===//
62// Local Utility Method Definitions
63//===----------------------------------------------------------------------===//

65namespace mlir {
66namespace arith {

68static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps0(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!(((type.isa<::mlir::FloatType>())) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isa<::mlir::FloatType>()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isa<::mlir::FloatType>()); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be floating-point-like, but got " << type;
}
return ::mlir::success();
76}

78static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps1(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!(((type.isSignlessIntOrIndex())) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be signless-integer-like, but got " << type;
}
return ::mlir::success();
86}

88static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps2(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!(((((type.isSignlessIntOrIndex())) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType())))) || (((type.isa<::mlir::FloatType>())) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isa<::mlir::FloatType>()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isa<::mlir::FloatType>()); }(type.cast<::mlir::ShapedType>().getElementType()))))) || (((type.isa<::mlir::MemRefType>())) && ([](::mlir::Type elementType) { return ((elementType.isSignlessInteger())) || ((elementType.isa<::mlir::IndexType>())) || ((elementType.isa<::mlir::FloatType>())); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be signless-integer-or-float-like or memref of signless-integer or float, but got " << type;
}
return ::mlir::success();
96}

98static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps3(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!(((type.isSignlessInteger(1))) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger(1)); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger(1)); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be bool-like, but got " << type;
}
return ::mlir::success();
106}

108static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps4(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!(((type.isSignlessIntOrIndex())) || (((type.isa<::mlir::VectorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be signless-integer-like, but got " << type;
}
return ::mlir::success();
116}

118static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps5(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!(((type.isSignlessInteger(1))) || (((type.isa<::mlir::VectorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger(1)); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger(1)); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be bool-like, but got " << type;
}
return ::mlir::success();
126}

128static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps6(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!((true))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be any type, but got " << type;
}
return ::mlir::success();
136}

138static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps7(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!(((type.isSignlessInteger())) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessInteger()); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be signless-fixed-width-integer-like, but got " << type;
}
return ::mlir::success();
146}

148static ::mlir::LogicalResult __mlir_ods_local_type_constraint_ArithmeticOps8(
  ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
  unsigned valueIndex) {
if (!((((type.isSignlessIntOrIndex())) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType())))) || (((type.isa<::mlir::MemRefType>())) && ([](::mlir::Type elementType) { return ((elementType.isSignlessInteger())) || ((elementType.isa<::mlir::IndexType>())); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
  return op->emitOpError(valueKind) << " #" << valueIndex
      << " must be signless-integer-like or memref of signless-integer, but got " << type;
}
return ::mlir::success();
156}

158static ::mlir::LogicalResult __mlir_ods_local_attr_constraint_ArithmeticOps0(
  ::mlir::Operation *op, ::mlir::Attribute attr, ::llvm::StringRef attrName) {
if (attr && !((attr.isa<::mlir::arith::CmpFPredicateAttr>()))) {
  return op->emitOpError("attribute '") << attrName
      << "' failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15";
}
return ::mlir::success();
165}

167static ::mlir::LogicalResult __mlir_ods_local_attr_constraint_ArithmeticOps1(
  ::mlir::Operation *op, ::mlir::Attribute attr, ::llvm::StringRef attrName) {
if (attr && !((attr.isa<::mlir::arith::CmpIPredicateAttr>()))) {
  return op->emitOpError("attribute '") << attrName
      << "' failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9";
}
return ::mlir::success();
174}

176static ::mlir::LogicalResult __mlir_ods_local_attr_constraint_ArithmeticOps2(
  ::mlir::Operation *op, ::mlir::Attribute attr, ::llvm::StringRef attrName) {
if (attr && !((true))) {
  return op->emitOpError("attribute '") << attrName
      << "' failed to satisfy constraint: any attribute";
}
return ::mlir::success();
183}
184} // namespace arith
185} // namespace mlir
186namespace mlir {
187namespace arith {

189//===----------------------------------------------------------------------===//
190// ::mlir::arith::AddFOp definitions
191//===----------------------------------------------------------------------===//

193AddFOpAdaptor::AddFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.addf", odsAttrs.getContext());
195}

197AddFOpAdaptor::AddFOpAdaptor(AddFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange AddFOpAdaptor::getOperands() {
return odsOperands;
201}

203std::pair<unsigned, unsigned> AddFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
205}

:mlir::ValueRange AddFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
211}

:mlir::Value AddFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
215}

:mlir::Value AddFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
219}

:mlir::DictionaryAttr AddFOpAdaptor::getAttributes() {
return odsAttrs;
223}

:mlir::LogicalResult AddFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
227}

229std::pair<unsigned, unsigned> AddFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
231}

:mlir::Operation::operand_range AddFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
237}

:mlir::Value AddFOp::getLhs() {
return *getODSOperands(0).begin();
241}

:mlir::Value AddFOp::getRhs() {
return *getODSOperands(1).begin();
245}

:mlir::MutableOperandRange AddFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
251}

:mlir::MutableOperandRange AddFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
257}

259std::pair<unsigned, unsigned> AddFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
261}

:mlir::Operation::result_range AddFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
267}

:mlir::Value AddFOp::getResult() {
return *getODSResults(0).begin();
271}

273void AddFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
277}

279void AddFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 282, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
284}

286void AddFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 287, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 290, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
292}

294void AddFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

299}

301void AddFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

306}

:mlir::LogicalResult AddFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
334}

:mlir::LogicalResult AddFOp::verifyInvariants() {
return verifyInvariantsImpl();
338}

:mlir::ParseResult AddFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
376}

378void AddFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
394}

396void AddFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
397}

399} // namespace arith
400} // namespace mlir
401MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::AddFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::AddFOp>::id = {}; } }

403namespace mlir {
404namespace arith {

406//===----------------------------------------------------------------------===//
407// ::mlir::arith::AddIOp definitions
408//===----------------------------------------------------------------------===//

410AddIOpAdaptor::AddIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.addi", odsAttrs.getContext());
412}

414AddIOpAdaptor::AddIOpAdaptor(AddIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange AddIOpAdaptor::getOperands() {
return odsOperands;
418}

420std::pair<unsigned, unsigned> AddIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
422}

:mlir::ValueRange AddIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
428}

:mlir::Value AddIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
432}

:mlir::Value AddIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
436}

:mlir::DictionaryAttr AddIOpAdaptor::getAttributes() {
return odsAttrs;
440}

:mlir::LogicalResult AddIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
444}

446std::pair<unsigned, unsigned> AddIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
448}

:mlir::Operation::operand_range AddIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
454}

:mlir::Value AddIOp::getLhs() {
return *getODSOperands(0).begin();
458}

:mlir::Value AddIOp::getRhs() {
return *getODSOperands(1).begin();
462}

:mlir::MutableOperandRange AddIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
468}

:mlir::MutableOperandRange AddIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
474}

476std::pair<unsigned, unsigned> AddIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
478}

:mlir::Operation::result_range AddIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
484}

:mlir::Value AddIOp::getResult() {
return *getODSResults(0).begin();
488}

490void AddIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
494}

496void AddIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 499, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
501}

503void AddIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 504, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 507, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
509}

511void AddIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

516}

518void AddIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

523}

:mlir::LogicalResult AddIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
551}

:mlir::LogicalResult AddIOp::verifyInvariants() {
return verifyInvariantsImpl();
555}

:mlir::ParseResult AddIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
593}

595void AddIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
611}

613void AddIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
614}

616} // namespace arith
617} // namespace mlir
618MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::AddIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::AddIOp>::id = {}; } }

620namespace mlir {
621namespace arith {

623//===----------------------------------------------------------------------===//
624// ::mlir::arith::AndIOp definitions
625//===----------------------------------------------------------------------===//

627AndIOpAdaptor::AndIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.andi", odsAttrs.getContext());
629}

631AndIOpAdaptor::AndIOpAdaptor(AndIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange AndIOpAdaptor::getOperands() {
return odsOperands;
635}

637std::pair<unsigned, unsigned> AndIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
639}

:mlir::ValueRange AndIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
645}

:mlir::Value AndIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
649}

:mlir::Value AndIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
653}

:mlir::DictionaryAttr AndIOpAdaptor::getAttributes() {
return odsAttrs;
657}

:mlir::LogicalResult AndIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
661}

663std::pair<unsigned, unsigned> AndIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
665}

:mlir::Operation::operand_range AndIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
671}

:mlir::Value AndIOp::getLhs() {
return *getODSOperands(0).begin();
675}

:mlir::Value AndIOp::getRhs() {
return *getODSOperands(1).begin();
679}

:mlir::MutableOperandRange AndIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
685}

:mlir::MutableOperandRange AndIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
691}

693std::pair<unsigned, unsigned> AndIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
695}

:mlir::Operation::result_range AndIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
701}

:mlir::Value AndIOp::getResult() {
return *getODSResults(0).begin();
705}

707void AndIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
711}

713void AndIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 716, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
718}

720void AndIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 721, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 724, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
726}

728void AndIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

733}

735void AndIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

740}

:mlir::LogicalResult AndIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
768}

:mlir::LogicalResult AndIOp::verifyInvariants() {
return verifyInvariantsImpl();
772}

:mlir::ParseResult AndIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
810}

812void AndIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
828}

830void AndIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
831}

833} // namespace arith
834} // namespace mlir
835MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::AndIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::AndIOp>::id = {}; } }

837namespace mlir {
838namespace arith {

840//===----------------------------------------------------------------------===//
841// ::mlir::arith::BitcastOp definitions
842//===----------------------------------------------------------------------===//

844BitcastOpAdaptor::BitcastOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.bitcast", odsAttrs.getContext());
846}

848BitcastOpAdaptor::BitcastOpAdaptor(BitcastOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange BitcastOpAdaptor::getOperands() {
return odsOperands;
852}

854std::pair<unsigned, unsigned> BitcastOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
856}

:mlir::ValueRange BitcastOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
862}

:mlir::Value BitcastOpAdaptor::getIn() {
return *getODSOperands(0).begin();
866}

:mlir::DictionaryAttr BitcastOpAdaptor::getAttributes() {
return odsAttrs;
870}

:mlir::LogicalResult BitcastOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
874}

876std::pair<unsigned, unsigned> BitcastOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
878}

:mlir::Operation::operand_range BitcastOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
884}

:mlir::Value BitcastOp::getIn() {
return *getODSOperands(0).begin();
888}

:mlir::MutableOperandRange BitcastOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
894}

896std::pair<unsigned, unsigned> BitcastOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
898}

:mlir::Operation::result_range BitcastOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
904}

:mlir::Value BitcastOp::getOut() {
return *getODSResults(0).begin();
908}

910void BitcastOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
913}

915void BitcastOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 917, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
919}

921void BitcastOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 922, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 925, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
927}

:mlir::LogicalResult BitcastOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps2(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps2(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
949}

:mlir::LogicalResult BitcastOp::verifyInvariants() {
return verifyInvariantsImpl();
953}

:mlir::ParseResult BitcastOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
991}

993void BitcastOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
1015}

1017void BitcastOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
1018}

1020} // namespace arith
1021} // namespace mlir
1022MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::BitcastOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::BitcastOp>::id = {}; } }

1024namespace mlir {
1025namespace arith {

1027//===----------------------------------------------------------------------===//
1028// ::mlir::arith::CeilDivSIOp definitions
1029//===----------------------------------------------------------------------===//

1031CeilDivSIOpAdaptor::CeilDivSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.ceildivsi", odsAttrs.getContext());
1033}

1035CeilDivSIOpAdaptor::CeilDivSIOpAdaptor(CeilDivSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange CeilDivSIOpAdaptor::getOperands() {
return odsOperands;
1039}

1041std::pair<unsigned, unsigned> CeilDivSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1043}

:mlir::ValueRange CeilDivSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1049}

:mlir::Value CeilDivSIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
1053}

:mlir::Value CeilDivSIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
1057}

:mlir::DictionaryAttr CeilDivSIOpAdaptor::getAttributes() {
return odsAttrs;
1061}

:mlir::LogicalResult CeilDivSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
1065}

1067std::pair<unsigned, unsigned> CeilDivSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1069}

:mlir::Operation::operand_range CeilDivSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
1075}

:mlir::Value CeilDivSIOp::getLhs() {
return *getODSOperands(0).begin();
1079}

:mlir::Value CeilDivSIOp::getRhs() {
return *getODSOperands(1).begin();
1083}

:mlir::MutableOperandRange CeilDivSIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1089}

:mlir::MutableOperandRange CeilDivSIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1095}

1097std::pair<unsigned, unsigned> CeilDivSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
1099}

:mlir::Operation::result_range CeilDivSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
1105}

:mlir::Value CeilDivSIOp::getResult() {
return *getODSResults(0).begin();
1109}

1111void CeilDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
1115}

1117void CeilDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1120, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1122}

1124void CeilDivSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1125, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1128, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1130}

1132void CeilDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

1137}

1139void CeilDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

1144}

:mlir::LogicalResult CeilDivSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
1172}

:mlir::LogicalResult CeilDivSIOp::verifyInvariants() {
return verifyInvariantsImpl();
1176}

:mlir::ParseResult CeilDivSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
1214}

1216void CeilDivSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
1232}

1234void CeilDivSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
1235}

1237} // namespace arith
1238} // namespace mlir
1239MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::CeilDivSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::CeilDivSIOp>::id = {}; } }

1241namespace mlir {
1242namespace arith {

1244//===----------------------------------------------------------------------===//
1245// ::mlir::arith::CeilDivUIOp definitions
1246//===----------------------------------------------------------------------===//

1248CeilDivUIOpAdaptor::CeilDivUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.ceildivui", odsAttrs.getContext());
1250}

1252CeilDivUIOpAdaptor::CeilDivUIOpAdaptor(CeilDivUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange CeilDivUIOpAdaptor::getOperands() {
return odsOperands;
1256}

1258std::pair<unsigned, unsigned> CeilDivUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1260}

:mlir::ValueRange CeilDivUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1266}

:mlir::Value CeilDivUIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
1270}

:mlir::Value CeilDivUIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
1274}

:mlir::DictionaryAttr CeilDivUIOpAdaptor::getAttributes() {
return odsAttrs;
1278}

:mlir::LogicalResult CeilDivUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
1282}

1284std::pair<unsigned, unsigned> CeilDivUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1286}

:mlir::Operation::operand_range CeilDivUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
1292}

:mlir::Value CeilDivUIOp::getLhs() {
return *getODSOperands(0).begin();
1296}

:mlir::Value CeilDivUIOp::getRhs() {
return *getODSOperands(1).begin();
1300}

:mlir::MutableOperandRange CeilDivUIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1306}

:mlir::MutableOperandRange CeilDivUIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1312}

1314std::pair<unsigned, unsigned> CeilDivUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
1316}

:mlir::Operation::result_range CeilDivUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
1322}

:mlir::Value CeilDivUIOp::getResult() {
return *getODSResults(0).begin();
1326}

1328void CeilDivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
1332}

1334void CeilDivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1337, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1339}

1341void CeilDivUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1342, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1345, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1347}

1349void CeilDivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

1354}

1356void CeilDivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

1361}

:mlir::LogicalResult CeilDivUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
1389}

:mlir::LogicalResult CeilDivUIOp::verifyInvariants() {
return verifyInvariantsImpl();
1393}

:mlir::ParseResult CeilDivUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
1431}

1433void CeilDivUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
1449}

1451void CeilDivUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
1452}

1454} // namespace arith
1455} // namespace mlir
1456MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::CeilDivUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::CeilDivUIOp>::id = {}; } }

1458namespace mlir {
1459namespace arith {

1461//===----------------------------------------------------------------------===//
1462// ::mlir::arith::CmpFOp definitions
1463//===----------------------------------------------------------------------===//

1465CmpFOpAdaptor::CmpFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.cmpf", odsAttrs.getContext());
1467}

1469CmpFOpAdaptor::CmpFOpAdaptor(CmpFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange CmpFOpAdaptor::getOperands() {
return odsOperands;
1473}

1475std::pair<unsigned, unsigned> CmpFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1477}

:mlir::ValueRange CmpFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1483}

:mlir::Value CmpFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
1487}

:mlir::Value CmpFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
1491}

:mlir::DictionaryAttr CmpFOpAdaptor::getAttributes() {
return odsAttrs;
1495}

:mlir::arith::CmpFPredicateAttr CmpFOpAdaptor::getPredicateAttr() {
assert(odsAttrs && "no attributes when constructing adapter")(static_cast <bool> (odsAttrs && "no attributes when constructing adapter"
) ? void (0) : __assert_fail ("odsAttrs && \"no attributes when constructing adapter\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1498, __extension__ __PRETTY_FUNCTION__));
auto attr = ::mlir::impl::getAttrFromSortedRange(odsAttrs.begin() + 0, odsAttrs.end() - 0, CmpFOp::getPredicateAttrName(*odsOpName)).cast<::mlir::arith::CmpFPredicateAttr>();
  return attr;
1501}

:mlir::arith::CmpFPredicate CmpFOpAdaptor::getPredicate() {
auto attr = getPredicateAttr();
return attr.getValue();
1506}

:mlir::LogicalResult CmpFOpAdaptor::verify(::mlir::Location loc) {
auto namedAttrRange = odsAttrs;
auto namedAttrIt = namedAttrRange.begin();
::mlir::Attribute tblgen_predicate;
while (true) {
  if (namedAttrIt == namedAttrRange.end())
    return emitError(loc, "'arith.cmpf' op ""requires attribute 'predicate'");
  if (namedAttrIt->getName() == CmpFOp::getPredicateAttrName(*odsOpName)) {
    tblgen_predicate = namedAttrIt->getValue();
    break;
  }
  ++namedAttrIt;
}

if (tblgen_predicate && !((tblgen_predicate.isa<::mlir::arith::CmpFPredicateAttr>())))
  return emitError(loc, "'arith.cmpf' op ""attribute 'predicate' failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15");
return ::mlir::success();
1525}

1527std::pair<unsigned, unsigned> CmpFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1529}

:mlir::Operation::operand_range CmpFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
1535}

:mlir::Value CmpFOp::getLhs() {
return *getODSOperands(0).begin();
1539}

:mlir::Value CmpFOp::getRhs() {
return *getODSOperands(1).begin();
1543}

:mlir::MutableOperandRange CmpFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1549}

:mlir::MutableOperandRange CmpFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1555}

1557std::pair<unsigned, unsigned> CmpFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
1559}

:mlir::Operation::result_range CmpFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
1565}

:mlir::Value CmpFOp::getResult() {
return *getODSResults(0).begin();
1569}

:mlir::arith::CmpFPredicateAttr CmpFOp::getPredicateAttr() {
return ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 0, (*this)->getAttrs().end() - 0, getPredicateAttrName()).cast<::mlir::arith::CmpFPredicateAttr>();
1573}

:mlir::arith::CmpFPredicate CmpFOp::getPredicate() {
auto attr = getPredicateAttr();
return attr.getValue();
1578}

1580void CmpFOp::setPredicateAttr(::mlir::arith::CmpFPredicateAttr attr) {
(*this)->setAttr(getPredicateAttrName(), attr);
1582}

1584void CmpFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, CmpFPredicate predicate, Value lhs, Value rhs) {
    build(odsBuilder, odsState, ::getI1SameShape(lhs.getType()),
          predicate, lhs, rhs);
  
1588}

1590void CmpFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::arith::CmpFPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), predicate);
odsState.addTypes(result);
1595}

1597void CmpFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arith::CmpFPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), predicate);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1601, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1603}

1605void CmpFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::arith::CmpFPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), ::mlir::arith::CmpFPredicateAttr::get(odsBuilder.getContext(), predicate));
odsState.addTypes(result);
1610}

1612void CmpFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arith::CmpFPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), ::mlir::arith::CmpFPredicateAttr::get(odsBuilder.getContext(), predicate));
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1616, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1618}

1620void CmpFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1621, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1624, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1626}

:mlir::LogicalResult CmpFOp::verifyInvariantsImpl() {
auto namedAttrRange = (*this)->getAttrs();
auto namedAttrIt = namedAttrRange.begin();
::mlir::Attribute tblgen_predicate;
while (true) {
  if (namedAttrIt == namedAttrRange.end())
    return emitOpError("requires attribute 'predicate'");
  if (namedAttrIt->getName() == getPredicateAttrName()) {
    tblgen_predicate = namedAttrIt->getValue();
    break;
  }
  ++namedAttrIt;
}

if (::mlir::failed(__mlir_ods_local_attr_constraint_ArithmeticOps0(*this, tblgen_predicate, "predicate")))
  return ::mlir::failure();
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps3(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
if (!((std::equal_to<>()(::getI1SameShape((*this->getODSOperands(0).begin()).getType()), (*this->getODSResults(0).begin()).getType()))))
  return emitOpError("failed to verify that result type has i1 element type and same shape as operands");
return ::mlir::success();
1671}

:mlir::LogicalResult CmpFOp::verifyInvariants() {
return verifyInvariantsImpl();
1675}

:mlir::ParseResult CmpFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::arith::CmpFPredicateAttr predicateAttr;
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type lhsRawTypes[1];
::llvm::ArrayRef<::mlir::Type> lhsTypes(lhsRawTypes);

{
  ::llvm::StringRef attrStr;
  ::mlir::NamedAttrList attrStorage;
  auto loc = parser.getCurrentLocation();
  if (parser.parseOptionalKeyword(&attrStr, {"false","oeq","ogt","oge","olt","ole","one","ord","ueq","ugt","uge","ult","ule","une","uno","true"})) {
    ::mlir::StringAttr attrVal;
    ::mlir::OptionalParseResult parseResult =
      parser.parseOptionalAttribute(attrVal,
                                    parser.getBuilder().getNoneType(),
                                    "predicate", attrStorage);
    if (parseResult.hasValue()) {
      if (failed(*parseResult))
        return ::mlir::failure();
      attrStr = attrVal.getValue();
    } else {
      return parser.emitError(loc, "expected string or keyword containing one of the following enum values for attribute 'predicate' [false, oeq, ogt, oge, olt, ole, one, ord, ueq, ugt, uge, ult, ule, une, uno, true]");
    }
  }
  if (!attrStr.empty()) {
    auto attrOptional = ::mlir::arith::symbolizeCmpFPredicate(attrStr);
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "predicate attribute specification: \"" << attrStr << '"';;

    predicateAttr = ::mlir::arith::CmpFPredicateAttr::get(parser.getBuilder().getContext(), attrOptional.getValue());
    result.addAttribute("predicate", predicateAttr);
  }
}
if (parser.parseComma())
  return ::mlir::failure();

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  lhsRawTypes[0] = type;
}
for (::mlir::Type type : lhsTypes) {
  (void)type;
  if (!(((type.isa<::mlir::FloatType>())) || ((((type.isa<::mlir::VectorType>())) && ((type.cast<::mlir::VectorType>().getRank() > 0))) && ([](::mlir::Type elementType) { return (elementType.isa<::mlir::FloatType>()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isa<::mlir::FloatType>()); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
    return parser.emitError(parser.getNameLoc()) << "'lhs' must be floating-point-like, but got " << type;
  }
}
result.addTypes(::getI1SameShape(lhsTypes[0]));
if (parser.resolveOperands(lhsOperands, lhsTypes, lhsOperandsLoc, result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, lhsTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
1751}

1753void CmpFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';

{
  auto caseValue = getPredicate();
  auto caseValueStr = stringifyCmpFPredicate(caseValue);
  _odsPrinter << caseValueStr;
}
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"predicate"});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getLhs().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
1777}

1779void CmpFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
1780}

1782} // namespace arith
1783} // namespace mlir
1784MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::CmpFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::CmpFOp>::id = {}; } }

1786namespace mlir {
1787namespace arith {

1789//===----------------------------------------------------------------------===//
1790// ::mlir::arith::CmpIOp definitions
1791//===----------------------------------------------------------------------===//

1793CmpIOpAdaptor::CmpIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.cmpi", odsAttrs.getContext());
1795}

1797CmpIOpAdaptor::CmpIOpAdaptor(CmpIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange CmpIOpAdaptor::getOperands() {
return odsOperands;
1801}

1803std::pair<unsigned, unsigned> CmpIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1805}

:mlir::ValueRange CmpIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
1811}

:mlir::Value CmpIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
1815}

:mlir::Value CmpIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
1819}

:mlir::DictionaryAttr CmpIOpAdaptor::getAttributes() {
return odsAttrs;
1823}

:mlir::arith::CmpIPredicateAttr CmpIOpAdaptor::getPredicateAttr() {
assert(odsAttrs && "no attributes when constructing adapter")(static_cast <bool> (odsAttrs && "no attributes when constructing adapter"
) ? void (0) : __assert_fail ("odsAttrs && \"no attributes when constructing adapter\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1826, __extension__ __PRETTY_FUNCTION__));
auto attr = ::mlir::impl::getAttrFromSortedRange(odsAttrs.begin() + 0, odsAttrs.end() - 0, CmpIOp::getPredicateAttrName(*odsOpName)).cast<::mlir::arith::CmpIPredicateAttr>();
  return attr;
1829}

:mlir::arith::CmpIPredicate CmpIOpAdaptor::getPredicate() {
auto attr = getPredicateAttr();
return attr.getValue();
1834}

:mlir::LogicalResult CmpIOpAdaptor::verify(::mlir::Location loc) {
auto namedAttrRange = odsAttrs;
auto namedAttrIt = namedAttrRange.begin();
::mlir::Attribute tblgen_predicate;
while (true) {
  if (namedAttrIt == namedAttrRange.end())
    return emitError(loc, "'arith.cmpi' op ""requires attribute 'predicate'");
  if (namedAttrIt->getName() == CmpIOp::getPredicateAttrName(*odsOpName)) {
    tblgen_predicate = namedAttrIt->getValue();
    break;
  }
  ++namedAttrIt;
}

if (tblgen_predicate && !((tblgen_predicate.isa<::mlir::arith::CmpIPredicateAttr>())))
  return emitError(loc, "'arith.cmpi' op ""attribute 'predicate' failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9");
return ::mlir::success();
1853}

1855std::pair<unsigned, unsigned> CmpIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
1857}

:mlir::Operation::operand_range CmpIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
1863}

:mlir::Value CmpIOp::getLhs() {
return *getODSOperands(0).begin();
1867}

:mlir::Value CmpIOp::getRhs() {
return *getODSOperands(1).begin();
1871}

:mlir::MutableOperandRange CmpIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1877}

:mlir::MutableOperandRange CmpIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
1883}

1885std::pair<unsigned, unsigned> CmpIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
1887}

:mlir::Operation::result_range CmpIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
1893}

:mlir::Value CmpIOp::getResult() {
return *getODSResults(0).begin();
1897}

:mlir::arith::CmpIPredicateAttr CmpIOp::getPredicateAttr() {
return ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 0, (*this)->getAttrs().end() - 0, getPredicateAttrName()).cast<::mlir::arith::CmpIPredicateAttr>();
1901}

:mlir::arith::CmpIPredicate CmpIOp::getPredicate() {
auto attr = getPredicateAttr();
return attr.getValue();
1906}

1908void CmpIOp::setPredicateAttr(::mlir::arith::CmpIPredicateAttr attr) {
(*this)->setAttr(getPredicateAttrName(), attr);
1910}

1912void CmpIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, CmpIPredicate predicate, Value lhs, Value rhs) {
    build(odsBuilder, odsState, ::getI1SameShape(lhs.getType()),
          predicate, lhs, rhs);
  
1916}

1918void CmpIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::arith::CmpIPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), predicate);
odsState.addTypes(result);
1923}

1925void CmpIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arith::CmpIPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), predicate);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1929, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1931}

1933void CmpIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::arith::CmpIPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), ::mlir::arith::CmpIPredicateAttr::get(odsBuilder.getContext(), predicate));
odsState.addTypes(result);
1938}

1940void CmpIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::arith::CmpIPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addAttribute(getPredicateAttrName(odsState.name), ::mlir::arith::CmpIPredicateAttr::get(odsBuilder.getContext(), predicate));
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1944, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1946}

1948void CmpIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1949, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 1952, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
1954}

:mlir::LogicalResult CmpIOp::verifyInvariantsImpl() {
auto namedAttrRange = (*this)->getAttrs();
auto namedAttrIt = namedAttrRange.begin();
::mlir::Attribute tblgen_predicate;
while (true) {
  if (namedAttrIt == namedAttrRange.end())
    return emitOpError("requires attribute 'predicate'");
  if (namedAttrIt->getName() == getPredicateAttrName()) {
    tblgen_predicate = namedAttrIt->getValue();
    break;
  }
  ++namedAttrIt;
}

if (::mlir::failed(__mlir_ods_local_attr_constraint_ArithmeticOps1(*this, tblgen_predicate, "predicate")))
  return ::mlir::failure();
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps4(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps4(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps5(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
if (!((std::equal_to<>()(::getI1SameShape((*this->getODSOperands(0).begin()).getType()), (*this->getODSResults(0).begin()).getType()))))
  return emitOpError("failed to verify that result type has i1 element type and same shape as operands");
return ::mlir::success();
1999}

:mlir::LogicalResult CmpIOp::verifyInvariants() {
return verifyInvariantsImpl();
2003}

:mlir::ParseResult CmpIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::arith::CmpIPredicateAttr predicateAttr;
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type lhsRawTypes[1];
::llvm::ArrayRef<::mlir::Type> lhsTypes(lhsRawTypes);

{
  ::llvm::StringRef attrStr;
  ::mlir::NamedAttrList attrStorage;
  auto loc = parser.getCurrentLocation();
  if (parser.parseOptionalKeyword(&attrStr, {"eq","ne","slt","sle","sgt","sge","ult","ule","ugt","uge"})) {
    ::mlir::StringAttr attrVal;
    ::mlir::OptionalParseResult parseResult =
      parser.parseOptionalAttribute(attrVal,
                                    parser.getBuilder().getNoneType(),
                                    "predicate", attrStorage);
    if (parseResult.hasValue()) {
      if (failed(*parseResult))
        return ::mlir::failure();
      attrStr = attrVal.getValue();
    } else {
      return parser.emitError(loc, "expected string or keyword containing one of the following enum values for attribute 'predicate' [eq, ne, slt, sle, sgt, sge, ult, ule, ugt, uge]");
    }
  }
  if (!attrStr.empty()) {
    auto attrOptional = ::mlir::arith::symbolizeCmpIPredicate(attrStr);
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "predicate attribute specification: \"" << attrStr << '"';;

    predicateAttr = ::mlir::arith::CmpIPredicateAttr::get(parser.getBuilder().getContext(), attrOptional.getValue());
    result.addAttribute("predicate", predicateAttr);
  }
}
if (parser.parseComma())
  return ::mlir::failure();

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  lhsRawTypes[0] = type;
}
for (::mlir::Type type : lhsTypes) {
  (void)type;
  if (!(((type.isSignlessIntOrIndex())) || (((type.isa<::mlir::VectorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))) || (((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (elementType.isSignlessIntOrIndex()); }(type.cast<::mlir::ShapedType>().getElementType()))))) {
    return parser.emitError(parser.getNameLoc()) << "'lhs' must be signless-integer-like, but got " << type;
  }
}
result.addTypes(::getI1SameShape(lhsTypes[0]));
if (parser.resolveOperands(lhsOperands, lhsTypes, lhsOperandsLoc, result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, lhsTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
2079}

2081void CmpIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';

{
  auto caseValue = getPredicate();
  auto caseValueStr = stringifyCmpIPredicate(caseValue);
  _odsPrinter << caseValueStr;
}
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"predicate"});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getLhs().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
2105}

2107void CmpIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
2108}

2110} // namespace arith
2111} // namespace mlir
2112MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::CmpIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::CmpIOp>::id = {}; } }

2114namespace mlir {
2115namespace arith {

2117//===----------------------------------------------------------------------===//
2118// ::mlir::arith::ConstantOp definitions
2119//===----------------------------------------------------------------------===//

2121ConstantOpAdaptor::ConstantOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.constant", odsAttrs.getContext());
2123}

2125ConstantOpAdaptor::ConstantOpAdaptor(ConstantOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange ConstantOpAdaptor::getOperands() {
return odsOperands;
2129}

2131std::pair<unsigned, unsigned> ConstantOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2133}

:mlir::ValueRange ConstantOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2139}

:mlir::DictionaryAttr ConstantOpAdaptor::getAttributes() {
return odsAttrs;
2143}

:mlir::Attribute ConstantOpAdaptor::getValueAttr() {
assert(odsAttrs && "no attributes when constructing adapter")(static_cast <bool> (odsAttrs && "no attributes when constructing adapter"
) ? void (0) : __assert_fail ("odsAttrs && \"no attributes when constructing adapter\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2146, __extension__ __PRETTY_FUNCTION__));
auto attr = ::mlir::impl::getAttrFromSortedRange(odsAttrs.begin() + 0, odsAttrs.end() - 0, ConstantOp::getValueAttrName(*odsOpName)).cast<::mlir::Attribute>();
  return attr;
2149}

:mlir::Attribute ConstantOpAdaptor::getValue() {
auto attr = getValueAttr();
return attr;
2154}

:mlir::LogicalResult ConstantOpAdaptor::verify(::mlir::Location loc) {
auto namedAttrRange = odsAttrs;
auto namedAttrIt = namedAttrRange.begin();
::mlir::Attribute tblgen_value;
while (true) {
  if (namedAttrIt == namedAttrRange.end())
    return emitError(loc, "'arith.constant' op ""requires attribute 'value'");
  if (namedAttrIt->getName() == ConstantOp::getValueAttrName(*odsOpName)) {
    tblgen_value = namedAttrIt->getValue();
    break;
  }
  ++namedAttrIt;
}

if (tblgen_value && !((true)))
  return emitError(loc, "'arith.constant' op ""attribute 'value' failed to satisfy constraint: any attribute");
return ::mlir::success();
2173}

2175std::pair<unsigned, unsigned> ConstantOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2177}

:mlir::Operation::operand_range ConstantOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
2183}

2185std::pair<unsigned, unsigned> ConstantOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
2187}

:mlir::Operation::result_range ConstantOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
2193}

:mlir::Value ConstantOp::getResult() {
return *getODSResults(0).begin();
2197}

:mlir::Attribute ConstantOp::getValueAttr() {
return ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 0, (*this)->getAttrs().end() - 0, getValueAttrName()).cast<::mlir::Attribute>();
2201}

:mlir::Attribute ConstantOp::getValue() {
auto attr = getValueAttr();
return attr;
2206}

2208void ConstantOp::setValueAttr(::mlir::Attribute attr) {
(*this)->setAttr(getValueAttrName(), attr);
2210}

2212void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Attribute value) {
build(odsBuilder, odsState, value.getType(), value); 
4
←
Calling 'Attribute::getType'→
2214}

2216void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Attribute value, Type type) {
build(odsBuilder, odsState, type, value); 
2218}

2220void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Attribute value) {
odsState.addAttribute(getValueAttrName(odsState.name), value);
odsState.addTypes(result);
2223}

2225void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Attribute value) {
odsState.addAttribute(getValueAttrName(odsState.name), value);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2227, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2229}

2231void ConstantOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 0u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 0u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 0u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2232, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2235, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2237}

:mlir::LogicalResult ConstantOp::verifyInvariantsImpl() {
auto namedAttrRange = (*this)->getAttrs();
auto namedAttrIt = namedAttrRange.begin();
::mlir::Attribute tblgen_value;
while (true) {
  if (namedAttrIt == namedAttrRange.end())
    return emitOpError("requires attribute 'value'");
  if (namedAttrIt->getName() == getValueAttrName()) {
    tblgen_value = namedAttrIt->getValue();
    break;
  }
  ++namedAttrIt;
}

if (::mlir::failed(__mlir_ods_local_attr_constraint_ArithmeticOps2(*this, tblgen_value, "value")))
  return ::mlir::failure();
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps6(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
if (!((std::equal_to<>()(::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 0, (*this)->getAttrs().end() - 0, getValueAttrName()).getType(), (*this->getODSResults(0).begin()).getType()))))
  return emitOpError("failed to verify that result and attribute have the same type");
return ::mlir::success();
2267}

:mlir::LogicalResult ConstantOp::verifyInvariants() {
if(::mlir::succeeded(verifyInvariantsImpl()) && ::mlir::succeeded(verify()))
  return ::mlir::success();
return ::mlir::failure();
2273}

:mlir::ParseResult ConstantOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::Attribute valueAttr;
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();

if (parser.parseAttribute(valueAttr, ::mlir::Type{}, "value", result.attributes))
  return ::mlir::failure();
result.addTypes(valueAttr.getType());
return ::mlir::success();
2284}

2286void ConstantOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"value"});
_odsPrinter << ' ';
_odsPrinter.printAttribute(getValueAttr());
2290}

2292void ConstantOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
2293}

2295} // namespace arith
2296} // namespace mlir
2297MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::ConstantOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::ConstantOp>::id = {}; } }

2299namespace mlir {
2300namespace arith {

2302//===----------------------------------------------------------------------===//
2303// ::mlir::arith::DivFOp definitions
2304//===----------------------------------------------------------------------===//

2306DivFOpAdaptor::DivFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.divf", odsAttrs.getContext());
2308}

2310DivFOpAdaptor::DivFOpAdaptor(DivFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange DivFOpAdaptor::getOperands() {
return odsOperands;
2314}

2316std::pair<unsigned, unsigned> DivFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2318}

:mlir::ValueRange DivFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2324}

:mlir::Value DivFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
2328}

:mlir::Value DivFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
2332}

:mlir::DictionaryAttr DivFOpAdaptor::getAttributes() {
return odsAttrs;
2336}

:mlir::LogicalResult DivFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
2340}

2342std::pair<unsigned, unsigned> DivFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2344}

:mlir::Operation::operand_range DivFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
2350}

:mlir::Value DivFOp::getLhs() {
return *getODSOperands(0).begin();
2354}

:mlir::Value DivFOp::getRhs() {
return *getODSOperands(1).begin();
2358}

:mlir::MutableOperandRange DivFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
2364}

:mlir::MutableOperandRange DivFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
2370}

2372std::pair<unsigned, unsigned> DivFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
2374}

:mlir::Operation::result_range DivFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
2380}

:mlir::Value DivFOp::getResult() {
return *getODSResults(0).begin();
2384}

2386void DivFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
2390}

2392void DivFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2395, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2397}

2399void DivFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2400, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2403, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2405}

2407void DivFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

2412}

2414void DivFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

2419}

:mlir::LogicalResult DivFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
2447}

:mlir::LogicalResult DivFOp::verifyInvariants() {
return verifyInvariantsImpl();
2451}

:mlir::ParseResult DivFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
2489}

2491void DivFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
2507}

2509void DivFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
2510}

2512} // namespace arith
2513} // namespace mlir
2514MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::DivFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::DivFOp>::id = {}; } }

2516namespace mlir {
2517namespace arith {

2519//===----------------------------------------------------------------------===//
2520// ::mlir::arith::DivSIOp definitions
2521//===----------------------------------------------------------------------===//

2523DivSIOpAdaptor::DivSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.divsi", odsAttrs.getContext());
2525}

2527DivSIOpAdaptor::DivSIOpAdaptor(DivSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange DivSIOpAdaptor::getOperands() {
return odsOperands;
2531}

2533std::pair<unsigned, unsigned> DivSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2535}

:mlir::ValueRange DivSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2541}

:mlir::Value DivSIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
2545}

:mlir::Value DivSIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
2549}

:mlir::DictionaryAttr DivSIOpAdaptor::getAttributes() {
return odsAttrs;
2553}

:mlir::LogicalResult DivSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
2557}

2559std::pair<unsigned, unsigned> DivSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2561}

:mlir::Operation::operand_range DivSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
2567}

:mlir::Value DivSIOp::getLhs() {
return *getODSOperands(0).begin();
2571}

:mlir::Value DivSIOp::getRhs() {
return *getODSOperands(1).begin();
2575}

:mlir::MutableOperandRange DivSIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
2581}

:mlir::MutableOperandRange DivSIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
2587}

2589std::pair<unsigned, unsigned> DivSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
2591}

:mlir::Operation::result_range DivSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
2597}

:mlir::Value DivSIOp::getResult() {
return *getODSResults(0).begin();
2601}

2603void DivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
2607}

2609void DivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2612, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2614}

2616void DivSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2617, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2620, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2622}

2624void DivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

2629}

2631void DivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

2636}

:mlir::LogicalResult DivSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
2664}

:mlir::LogicalResult DivSIOp::verifyInvariants() {
return verifyInvariantsImpl();
2668}

:mlir::ParseResult DivSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
2706}

2708void DivSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
2724}

2726void DivSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
2727}

2729} // namespace arith
2730} // namespace mlir
2731MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::DivSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::DivSIOp>::id = {}; } }

2733namespace mlir {
2734namespace arith {

2736//===----------------------------------------------------------------------===//
2737// ::mlir::arith::DivUIOp definitions
2738//===----------------------------------------------------------------------===//

2740DivUIOpAdaptor::DivUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.divui", odsAttrs.getContext());
2742}

2744DivUIOpAdaptor::DivUIOpAdaptor(DivUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange DivUIOpAdaptor::getOperands() {
return odsOperands;
2748}

2750std::pair<unsigned, unsigned> DivUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2752}

:mlir::ValueRange DivUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2758}

:mlir::Value DivUIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
2762}

:mlir::Value DivUIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
2766}

:mlir::DictionaryAttr DivUIOpAdaptor::getAttributes() {
return odsAttrs;
2770}

:mlir::LogicalResult DivUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
2774}

2776std::pair<unsigned, unsigned> DivUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2778}

:mlir::Operation::operand_range DivUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
2784}

:mlir::Value DivUIOp::getLhs() {
return *getODSOperands(0).begin();
2788}

:mlir::Value DivUIOp::getRhs() {
return *getODSOperands(1).begin();
2792}

:mlir::MutableOperandRange DivUIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
2798}

:mlir::MutableOperandRange DivUIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
2804}

2806std::pair<unsigned, unsigned> DivUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
2808}

:mlir::Operation::result_range DivUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
2814}

:mlir::Value DivUIOp::getResult() {
return *getODSResults(0).begin();
2818}

2820void DivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
2824}

2826void DivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2829, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2831}

2833void DivUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2834, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 2837, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
2839}

2841void DivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

2846}

2848void DivUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

2853}

:mlir::LogicalResult DivUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
2881}

:mlir::LogicalResult DivUIOp::verifyInvariants() {
return verifyInvariantsImpl();
2885}

:mlir::ParseResult DivUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
2923}

2925void DivUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
2941}

2943void DivUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
2944}

2946} // namespace arith
2947} // namespace mlir
2948MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::DivUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::DivUIOp>::id = {}; } }

2950namespace mlir {
2951namespace arith {

2953//===----------------------------------------------------------------------===//
2954// ::mlir::arith::ExtFOp definitions
2955//===----------------------------------------------------------------------===//

2957ExtFOpAdaptor::ExtFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.extf", odsAttrs.getContext());
2959}

2961ExtFOpAdaptor::ExtFOpAdaptor(ExtFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange ExtFOpAdaptor::getOperands() {
return odsOperands;
2965}

2967std::pair<unsigned, unsigned> ExtFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2969}

:mlir::ValueRange ExtFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
2975}

:mlir::Value ExtFOpAdaptor::getIn() {
return *getODSOperands(0).begin();
2979}

:mlir::DictionaryAttr ExtFOpAdaptor::getAttributes() {
return odsAttrs;
2983}

:mlir::LogicalResult ExtFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
2987}

2989std::pair<unsigned, unsigned> ExtFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
2991}

:mlir::Operation::operand_range ExtFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
2997}

:mlir::Value ExtFOp::getIn() {
return *getODSOperands(0).begin();
3001}

:mlir::MutableOperandRange ExtFOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
3007}

3009std::pair<unsigned, unsigned> ExtFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
3011}

:mlir::Operation::result_range ExtFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
3017}

:mlir::Value ExtFOp::getOut() {
return *getODSResults(0).begin();
3021}

3023void ExtFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
3026}

3028void ExtFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3030, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3032}

3034void ExtFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3035, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3038, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3040}

:mlir::LogicalResult ExtFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
3062}

:mlir::LogicalResult ExtFOp::verifyInvariants() {
if(::mlir::succeeded(verifyInvariantsImpl()) && ::mlir::succeeded(verify()))
  return ::mlir::success();
return ::mlir::failure();
3068}

:mlir::ParseResult ExtFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
3106}

3108void ExtFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
3130}

3132void ExtFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
3133}

3135} // namespace arith
3136} // namespace mlir
3137MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::ExtFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::ExtFOp>::id = {}; } }

3139namespace mlir {
3140namespace arith {

3142//===----------------------------------------------------------------------===//
3143// ::mlir::arith::ExtSIOp definitions
3144//===----------------------------------------------------------------------===//

3146ExtSIOpAdaptor::ExtSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.extsi", odsAttrs.getContext());
3148}

3150ExtSIOpAdaptor::ExtSIOpAdaptor(ExtSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange ExtSIOpAdaptor::getOperands() {
return odsOperands;
3154}

3156std::pair<unsigned, unsigned> ExtSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3158}

:mlir::ValueRange ExtSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3164}

:mlir::Value ExtSIOpAdaptor::getIn() {
return *getODSOperands(0).begin();
3168}

:mlir::DictionaryAttr ExtSIOpAdaptor::getAttributes() {
return odsAttrs;
3172}

:mlir::LogicalResult ExtSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
3176}

3178std::pair<unsigned, unsigned> ExtSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3180}

:mlir::Operation::operand_range ExtSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
3186}

:mlir::Value ExtSIOp::getIn() {
return *getODSOperands(0).begin();
3190}

:mlir::MutableOperandRange ExtSIOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
3196}

3198std::pair<unsigned, unsigned> ExtSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
3200}

:mlir::Operation::result_range ExtSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
3206}

:mlir::Value ExtSIOp::getOut() {
return *getODSResults(0).begin();
3210}

3212void ExtSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
3215}

3217void ExtSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3219, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3221}

3223void ExtSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3224, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3227, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3229}

:mlir::LogicalResult ExtSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
3251}

:mlir::LogicalResult ExtSIOp::verifyInvariants() {
if(::mlir::succeeded(verifyInvariantsImpl()) && ::mlir::succeeded(verify()))
  return ::mlir::success();
return ::mlir::failure();
3257}

:mlir::ParseResult ExtSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
3295}

3297void ExtSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
3319}

3321void ExtSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
3322}

3324} // namespace arith
3325} // namespace mlir
3326MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::ExtSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::ExtSIOp>::id = {}; } }

3328namespace mlir {
3329namespace arith {

3331//===----------------------------------------------------------------------===//
3332// ::mlir::arith::ExtUIOp definitions
3333//===----------------------------------------------------------------------===//

3335ExtUIOpAdaptor::ExtUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.extui", odsAttrs.getContext());
3337}

3339ExtUIOpAdaptor::ExtUIOpAdaptor(ExtUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange ExtUIOpAdaptor::getOperands() {
return odsOperands;
3343}

3345std::pair<unsigned, unsigned> ExtUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3347}

:mlir::ValueRange ExtUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3353}

:mlir::Value ExtUIOpAdaptor::getIn() {
return *getODSOperands(0).begin();
3357}

:mlir::DictionaryAttr ExtUIOpAdaptor::getAttributes() {
return odsAttrs;
3361}

:mlir::LogicalResult ExtUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
3365}

3367std::pair<unsigned, unsigned> ExtUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3369}

:mlir::Operation::operand_range ExtUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
3375}

:mlir::Value ExtUIOp::getIn() {
return *getODSOperands(0).begin();
3379}

:mlir::MutableOperandRange ExtUIOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
3385}

3387std::pair<unsigned, unsigned> ExtUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
3389}

:mlir::Operation::result_range ExtUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
3395}

:mlir::Value ExtUIOp::getOut() {
return *getODSResults(0).begin();
3399}

3401void ExtUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
3404}

3406void ExtUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3408, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3410}

3412void ExtUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3413, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3416, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3418}

:mlir::LogicalResult ExtUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
3440}

:mlir::LogicalResult ExtUIOp::verifyInvariants() {
if(::mlir::succeeded(verifyInvariantsImpl()) && ::mlir::succeeded(verify()))
  return ::mlir::success();
return ::mlir::failure();
3446}

:mlir::ParseResult ExtUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
3484}

3486void ExtUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
3508}

3510void ExtUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
3511}

3513} // namespace arith
3514} // namespace mlir
3515MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::ExtUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::ExtUIOp>::id = {}; } }

3517namespace mlir {
3518namespace arith {

3520//===----------------------------------------------------------------------===//
3521// ::mlir::arith::FPToSIOp definitions
3522//===----------------------------------------------------------------------===//

3524FPToSIOpAdaptor::FPToSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.fptosi", odsAttrs.getContext());
3526}

3528FPToSIOpAdaptor::FPToSIOpAdaptor(FPToSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange FPToSIOpAdaptor::getOperands() {
return odsOperands;
3532}

3534std::pair<unsigned, unsigned> FPToSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3536}

:mlir::ValueRange FPToSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3542}

:mlir::Value FPToSIOpAdaptor::getIn() {
return *getODSOperands(0).begin();
3546}

:mlir::DictionaryAttr FPToSIOpAdaptor::getAttributes() {
return odsAttrs;
3550}

:mlir::LogicalResult FPToSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
3554}

3556std::pair<unsigned, unsigned> FPToSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3558}

:mlir::Operation::operand_range FPToSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
3564}

:mlir::Value FPToSIOp::getIn() {
return *getODSOperands(0).begin();
3568}

:mlir::MutableOperandRange FPToSIOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
3574}

3576std::pair<unsigned, unsigned> FPToSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
3578}

:mlir::Operation::result_range FPToSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
3584}

:mlir::Value FPToSIOp::getOut() {
return *getODSResults(0).begin();
3588}

3590void FPToSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
3593}

3595void FPToSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3597, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3599}

3601void FPToSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3602, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3605, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3607}

:mlir::LogicalResult FPToSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
3629}

:mlir::LogicalResult FPToSIOp::verifyInvariants() {
return verifyInvariantsImpl();
3633}

:mlir::ParseResult FPToSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
3671}

3673void FPToSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
3695}

3697void FPToSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
3698}

3700} // namespace arith
3701} // namespace mlir
3702MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::FPToSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::FPToSIOp>::id = {}; } }

3704namespace mlir {
3705namespace arith {

3707//===----------------------------------------------------------------------===//
3708// ::mlir::arith::FPToUIOp definitions
3709//===----------------------------------------------------------------------===//

3711FPToUIOpAdaptor::FPToUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.fptoui", odsAttrs.getContext());
3713}

3715FPToUIOpAdaptor::FPToUIOpAdaptor(FPToUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange FPToUIOpAdaptor::getOperands() {
return odsOperands;
3719}

3721std::pair<unsigned, unsigned> FPToUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3723}

:mlir::ValueRange FPToUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3729}

:mlir::Value FPToUIOpAdaptor::getIn() {
return *getODSOperands(0).begin();
3733}

:mlir::DictionaryAttr FPToUIOpAdaptor::getAttributes() {
return odsAttrs;
3737}

:mlir::LogicalResult FPToUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
3741}

3743std::pair<unsigned, unsigned> FPToUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3745}

:mlir::Operation::operand_range FPToUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
3751}

:mlir::Value FPToUIOp::getIn() {
return *getODSOperands(0).begin();
3755}

:mlir::MutableOperandRange FPToUIOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
3761}

3763std::pair<unsigned, unsigned> FPToUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
3765}

:mlir::Operation::result_range FPToUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
3771}

:mlir::Value FPToUIOp::getOut() {
return *getODSResults(0).begin();
3775}

3777void FPToUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
3780}

3782void FPToUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3784, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3786}

3788void FPToUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3789, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3792, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3794}

:mlir::LogicalResult FPToUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
3816}

:mlir::LogicalResult FPToUIOp::verifyInvariants() {
return verifyInvariantsImpl();
3820}

:mlir::ParseResult FPToUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
3858}

3860void FPToUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
3882}

3884void FPToUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
3885}

3887} // namespace arith
3888} // namespace mlir
3889MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::FPToUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::FPToUIOp>::id = {}; } }

3891namespace mlir {
3892namespace arith {

3894//===----------------------------------------------------------------------===//
3895// ::mlir::arith::FloorDivSIOp definitions
3896//===----------------------------------------------------------------------===//

3898FloorDivSIOpAdaptor::FloorDivSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.floordivsi", odsAttrs.getContext());
3900}

3902FloorDivSIOpAdaptor::FloorDivSIOpAdaptor(FloorDivSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange FloorDivSIOpAdaptor::getOperands() {
return odsOperands;
3906}

3908std::pair<unsigned, unsigned> FloorDivSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3910}

:mlir::ValueRange FloorDivSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
3916}

:mlir::Value FloorDivSIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
3920}

:mlir::Value FloorDivSIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
3924}

:mlir::DictionaryAttr FloorDivSIOpAdaptor::getAttributes() {
return odsAttrs;
3928}

:mlir::LogicalResult FloorDivSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
3932}

3934std::pair<unsigned, unsigned> FloorDivSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
3936}

:mlir::Operation::operand_range FloorDivSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
3942}

:mlir::Value FloorDivSIOp::getLhs() {
return *getODSOperands(0).begin();
3946}

:mlir::Value FloorDivSIOp::getRhs() {
return *getODSOperands(1).begin();
3950}

:mlir::MutableOperandRange FloorDivSIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
3956}

:mlir::MutableOperandRange FloorDivSIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
3962}

3964std::pair<unsigned, unsigned> FloorDivSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
3966}

:mlir::Operation::result_range FloorDivSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
3972}

:mlir::Value FloorDivSIOp::getResult() {
return *getODSResults(0).begin();
3976}

3978void FloorDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
3982}

3984void FloorDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3987, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3989}

3991void FloorDivSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3992, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 3995, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
3997}

3999void FloorDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

4004}

4006void FloorDivSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

4011}

:mlir::LogicalResult FloorDivSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
4039}

:mlir::LogicalResult FloorDivSIOp::verifyInvariants() {
return verifyInvariantsImpl();
4043}

:mlir::ParseResult FloorDivSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
4081}

4083void FloorDivSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
4099}

4101void FloorDivSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
4102}

4104} // namespace arith
4105} // namespace mlir
4106MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::FloorDivSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::FloorDivSIOp>::id = {}; } }

4108namespace mlir {
4109namespace arith {

4111//===----------------------------------------------------------------------===//
4112// ::mlir::arith::IndexCastOp definitions
4113//===----------------------------------------------------------------------===//

4115IndexCastOpAdaptor::IndexCastOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.index_cast", odsAttrs.getContext());
4117}

4119IndexCastOpAdaptor::IndexCastOpAdaptor(IndexCastOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange IndexCastOpAdaptor::getOperands() {
return odsOperands;
4123}

4125std::pair<unsigned, unsigned> IndexCastOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4127}

:mlir::ValueRange IndexCastOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4133}

:mlir::Value IndexCastOpAdaptor::getIn() {
return *getODSOperands(0).begin();
4137}

:mlir::DictionaryAttr IndexCastOpAdaptor::getAttributes() {
return odsAttrs;
4141}

:mlir::LogicalResult IndexCastOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
4145}

4147std::pair<unsigned, unsigned> IndexCastOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4149}

:mlir::Operation::operand_range IndexCastOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
4155}

:mlir::Value IndexCastOp::getIn() {
return *getODSOperands(0).begin();
4159}

:mlir::MutableOperandRange IndexCastOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
4165}

4167std::pair<unsigned, unsigned> IndexCastOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
4169}

:mlir::Operation::result_range IndexCastOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
4175}

:mlir::Value IndexCastOp::getOut() {
return *getODSResults(0).begin();
4179}

4181void IndexCastOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
4184}

4186void IndexCastOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4188, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4190}

4192void IndexCastOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4193, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4196, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4198}

:mlir::LogicalResult IndexCastOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps8(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps8(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
4220}

:mlir::LogicalResult IndexCastOp::verifyInvariants() {
return verifyInvariantsImpl();
4224}

:mlir::ParseResult IndexCastOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
4262}

4264void IndexCastOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
4286}

4288void IndexCastOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
4289}

4291} // namespace arith
4292} // namespace mlir
4293MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::IndexCastOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::IndexCastOp>::id = {}; } }

4295namespace mlir {
4296namespace arith {

4298//===----------------------------------------------------------------------===//
4299// ::mlir::arith::MaxFOp definitions
4300//===----------------------------------------------------------------------===//

4302MaxFOpAdaptor::MaxFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.maxf", odsAttrs.getContext());
4304}

4306MaxFOpAdaptor::MaxFOpAdaptor(MaxFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MaxFOpAdaptor::getOperands() {
return odsOperands;
4310}

4312std::pair<unsigned, unsigned> MaxFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4314}

:mlir::ValueRange MaxFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4320}

:mlir::Value MaxFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
4324}

:mlir::Value MaxFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
4328}

:mlir::DictionaryAttr MaxFOpAdaptor::getAttributes() {
return odsAttrs;
4332}

:mlir::LogicalResult MaxFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
4336}

4338std::pair<unsigned, unsigned> MaxFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4340}

:mlir::Operation::operand_range MaxFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
4346}

:mlir::Value MaxFOp::getLhs() {
return *getODSOperands(0).begin();
4350}

:mlir::Value MaxFOp::getRhs() {
return *getODSOperands(1).begin();
4354}

:mlir::MutableOperandRange MaxFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
4360}

:mlir::MutableOperandRange MaxFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
4366}

4368std::pair<unsigned, unsigned> MaxFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
4370}

:mlir::Operation::result_range MaxFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
4376}

:mlir::Value MaxFOp::getResult() {
return *getODSResults(0).begin();
4380}

4382void MaxFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
4386}

4388void MaxFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4391, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4393}

4395void MaxFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4396, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4399, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4401}

4403void MaxFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

4408}

4410void MaxFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

4415}

:mlir::LogicalResult MaxFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
4443}

:mlir::LogicalResult MaxFOp::verifyInvariants() {
return verifyInvariantsImpl();
4447}

:mlir::ParseResult MaxFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
4485}

4487void MaxFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
4503}

4505void MaxFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
4506}

4508} // namespace arith
4509} // namespace mlir
4510MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MaxFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MaxFOp>::id = {}; } }

4512namespace mlir {
4513namespace arith {

4515//===----------------------------------------------------------------------===//
4516// ::mlir::arith::MaxSIOp definitions
4517//===----------------------------------------------------------------------===//

4519MaxSIOpAdaptor::MaxSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.maxsi", odsAttrs.getContext());
4521}

4523MaxSIOpAdaptor::MaxSIOpAdaptor(MaxSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MaxSIOpAdaptor::getOperands() {
return odsOperands;
4527}

4529std::pair<unsigned, unsigned> MaxSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4531}

:mlir::ValueRange MaxSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4537}

:mlir::Value MaxSIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
4541}

:mlir::Value MaxSIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
4545}

:mlir::DictionaryAttr MaxSIOpAdaptor::getAttributes() {
return odsAttrs;
4549}

:mlir::LogicalResult MaxSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
4553}

4555std::pair<unsigned, unsigned> MaxSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4557}

:mlir::Operation::operand_range MaxSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
4563}

:mlir::Value MaxSIOp::getLhs() {
return *getODSOperands(0).begin();
4567}

:mlir::Value MaxSIOp::getRhs() {
return *getODSOperands(1).begin();
4571}

:mlir::MutableOperandRange MaxSIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
4577}

:mlir::MutableOperandRange MaxSIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
4583}

4585std::pair<unsigned, unsigned> MaxSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
4587}

:mlir::Operation::result_range MaxSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
4593}

:mlir::Value MaxSIOp::getResult() {
return *getODSResults(0).begin();
4597}

4599void MaxSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
4603}

4605void MaxSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4608, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4610}

4612void MaxSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4613, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4616, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4618}

4620void MaxSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

4625}

4627void MaxSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

4632}

:mlir::LogicalResult MaxSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
4660}

:mlir::LogicalResult MaxSIOp::verifyInvariants() {
return verifyInvariantsImpl();
4664}

:mlir::ParseResult MaxSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
4702}

4704void MaxSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
4720}

4722void MaxSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
4723}

4725} // namespace arith
4726} // namespace mlir
4727MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MaxSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MaxSIOp>::id = {}; } }

4729namespace mlir {
4730namespace arith {

4732//===----------------------------------------------------------------------===//
4733// ::mlir::arith::MaxUIOp definitions
4734//===----------------------------------------------------------------------===//

4736MaxUIOpAdaptor::MaxUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.maxui", odsAttrs.getContext());
4738}

4740MaxUIOpAdaptor::MaxUIOpAdaptor(MaxUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MaxUIOpAdaptor::getOperands() {
return odsOperands;
4744}

4746std::pair<unsigned, unsigned> MaxUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4748}

:mlir::ValueRange MaxUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4754}

:mlir::Value MaxUIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
4758}

:mlir::Value MaxUIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
4762}

:mlir::DictionaryAttr MaxUIOpAdaptor::getAttributes() {
return odsAttrs;
4766}

:mlir::LogicalResult MaxUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
4770}

4772std::pair<unsigned, unsigned> MaxUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4774}

:mlir::Operation::operand_range MaxUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
4780}

:mlir::Value MaxUIOp::getLhs() {
return *getODSOperands(0).begin();
4784}

:mlir::Value MaxUIOp::getRhs() {
return *getODSOperands(1).begin();
4788}

:mlir::MutableOperandRange MaxUIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
4794}

:mlir::MutableOperandRange MaxUIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
4800}

4802std::pair<unsigned, unsigned> MaxUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
4804}

:mlir::Operation::result_range MaxUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
4810}

:mlir::Value MaxUIOp::getResult() {
return *getODSResults(0).begin();
4814}

4816void MaxUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
4820}

4822void MaxUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4825, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4827}

4829void MaxUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4830, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 4833, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
4835}

4837void MaxUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

4842}

4844void MaxUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

4849}

:mlir::LogicalResult MaxUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
4877}

:mlir::LogicalResult MaxUIOp::verifyInvariants() {
return verifyInvariantsImpl();
4881}

:mlir::ParseResult MaxUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
4919}

4921void MaxUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
4937}

4939void MaxUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
4940}

4942} // namespace arith
4943} // namespace mlir
4944MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MaxUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MaxUIOp>::id = {}; } }

4946namespace mlir {
4947namespace arith {

4949//===----------------------------------------------------------------------===//
4950// ::mlir::arith::MinFOp definitions
4951//===----------------------------------------------------------------------===//

4953MinFOpAdaptor::MinFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.minf", odsAttrs.getContext());
4955}

4957MinFOpAdaptor::MinFOpAdaptor(MinFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MinFOpAdaptor::getOperands() {
return odsOperands;
4961}

4963std::pair<unsigned, unsigned> MinFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4965}

:mlir::ValueRange MinFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
4971}

:mlir::Value MinFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
4975}

:mlir::Value MinFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
4979}

:mlir::DictionaryAttr MinFOpAdaptor::getAttributes() {
return odsAttrs;
4983}

:mlir::LogicalResult MinFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
4987}

4989std::pair<unsigned, unsigned> MinFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
4991}

:mlir::Operation::operand_range MinFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
4997}

:mlir::Value MinFOp::getLhs() {
return *getODSOperands(0).begin();
5001}

:mlir::Value MinFOp::getRhs() {
return *getODSOperands(1).begin();
5005}

:mlir::MutableOperandRange MinFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5011}

:mlir::MutableOperandRange MinFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5017}

5019std::pair<unsigned, unsigned> MinFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
5021}

:mlir::Operation::result_range MinFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
5027}

:mlir::Value MinFOp::getResult() {
return *getODSResults(0).begin();
5031}

5033void MinFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
5037}

5039void MinFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5042, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5044}

5046void MinFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5047, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5050, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5052}

5054void MinFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

5059}

5061void MinFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

5066}

:mlir::LogicalResult MinFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
5094}

:mlir::LogicalResult MinFOp::verifyInvariants() {
return verifyInvariantsImpl();
5098}

:mlir::ParseResult MinFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
5136}

5138void MinFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
5154}

5156void MinFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
5157}

5159} // namespace arith
5160} // namespace mlir
5161MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MinFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MinFOp>::id = {}; } }

5163namespace mlir {
5164namespace arith {

5166//===----------------------------------------------------------------------===//
5167// ::mlir::arith::MinSIOp definitions
5168//===----------------------------------------------------------------------===//

5170MinSIOpAdaptor::MinSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.minsi", odsAttrs.getContext());
5172}

5174MinSIOpAdaptor::MinSIOpAdaptor(MinSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MinSIOpAdaptor::getOperands() {
return odsOperands;
5178}

5180std::pair<unsigned, unsigned> MinSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5182}

:mlir::ValueRange MinSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
5188}

:mlir::Value MinSIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
5192}

:mlir::Value MinSIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
5196}

:mlir::DictionaryAttr MinSIOpAdaptor::getAttributes() {
return odsAttrs;
5200}

:mlir::LogicalResult MinSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
5204}

5206std::pair<unsigned, unsigned> MinSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5208}

:mlir::Operation::operand_range MinSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
5214}

:mlir::Value MinSIOp::getLhs() {
return *getODSOperands(0).begin();
5218}

:mlir::Value MinSIOp::getRhs() {
return *getODSOperands(1).begin();
5222}

:mlir::MutableOperandRange MinSIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5228}

:mlir::MutableOperandRange MinSIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5234}

5236std::pair<unsigned, unsigned> MinSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
5238}

:mlir::Operation::result_range MinSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
5244}

:mlir::Value MinSIOp::getResult() {
return *getODSResults(0).begin();
5248}

5250void MinSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
5254}

5256void MinSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5259, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5261}

5263void MinSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5264, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5267, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5269}

5271void MinSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

5276}

5278void MinSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

5283}

:mlir::LogicalResult MinSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
5311}

:mlir::LogicalResult MinSIOp::verifyInvariants() {
return verifyInvariantsImpl();
5315}

:mlir::ParseResult MinSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
5353}

5355void MinSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
5371}

5373void MinSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
5374}

5376} // namespace arith
5377} // namespace mlir
5378MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MinSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MinSIOp>::id = {}; } }

5380namespace mlir {
5381namespace arith {

5383//===----------------------------------------------------------------------===//
5384// ::mlir::arith::MinUIOp definitions
5385//===----------------------------------------------------------------------===//

5387MinUIOpAdaptor::MinUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.minui", odsAttrs.getContext());
5389}

5391MinUIOpAdaptor::MinUIOpAdaptor(MinUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MinUIOpAdaptor::getOperands() {
return odsOperands;
5395}

5397std::pair<unsigned, unsigned> MinUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5399}

:mlir::ValueRange MinUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
5405}

:mlir::Value MinUIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
5409}

:mlir::Value MinUIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
5413}

:mlir::DictionaryAttr MinUIOpAdaptor::getAttributes() {
return odsAttrs;
5417}

:mlir::LogicalResult MinUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
5421}

5423std::pair<unsigned, unsigned> MinUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5425}

:mlir::Operation::operand_range MinUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
5431}

:mlir::Value MinUIOp::getLhs() {
return *getODSOperands(0).begin();
5435}

:mlir::Value MinUIOp::getRhs() {
return *getODSOperands(1).begin();
5439}

:mlir::MutableOperandRange MinUIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5445}

:mlir::MutableOperandRange MinUIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5451}

5453std::pair<unsigned, unsigned> MinUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
5455}

:mlir::Operation::result_range MinUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
5461}

:mlir::Value MinUIOp::getResult() {
return *getODSResults(0).begin();
5465}

5467void MinUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
5471}

5473void MinUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5476, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5478}

5480void MinUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5481, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5484, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5486}

5488void MinUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

5493}

5495void MinUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

5500}

:mlir::LogicalResult MinUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
5528}

:mlir::LogicalResult MinUIOp::verifyInvariants() {
return verifyInvariantsImpl();
5532}

:mlir::ParseResult MinUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
5570}

5572void MinUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
5588}

5590void MinUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
5591}

5593} // namespace arith
5594} // namespace mlir
5595MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MinUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MinUIOp>::id = {}; } }

5597namespace mlir {
5598namespace arith {

5600//===----------------------------------------------------------------------===//
5601// ::mlir::arith::MulFOp definitions
5602//===----------------------------------------------------------------------===//

5604MulFOpAdaptor::MulFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.mulf", odsAttrs.getContext());
5606}

5608MulFOpAdaptor::MulFOpAdaptor(MulFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MulFOpAdaptor::getOperands() {
return odsOperands;
5612}

5614std::pair<unsigned, unsigned> MulFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5616}

:mlir::ValueRange MulFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
5622}

:mlir::Value MulFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
5626}

:mlir::Value MulFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
5630}

:mlir::DictionaryAttr MulFOpAdaptor::getAttributes() {
return odsAttrs;
5634}

:mlir::LogicalResult MulFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
5638}

5640std::pair<unsigned, unsigned> MulFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5642}

:mlir::Operation::operand_range MulFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
5648}

:mlir::Value MulFOp::getLhs() {
return *getODSOperands(0).begin();
5652}

:mlir::Value MulFOp::getRhs() {
return *getODSOperands(1).begin();
5656}

:mlir::MutableOperandRange MulFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5662}

:mlir::MutableOperandRange MulFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5668}

5670std::pair<unsigned, unsigned> MulFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
5672}

:mlir::Operation::result_range MulFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
5678}

:mlir::Value MulFOp::getResult() {
return *getODSResults(0).begin();
5682}

5684void MulFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
5688}

5690void MulFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5693, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5695}

5697void MulFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5698, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5701, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5703}

5705void MulFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

5710}

5712void MulFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

5717}

:mlir::LogicalResult MulFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
5745}

:mlir::LogicalResult MulFOp::verifyInvariants() {
return verifyInvariantsImpl();
5749}

:mlir::ParseResult MulFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
5787}

5789void MulFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
5805}

5807void MulFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
5808}

5810} // namespace arith
5811} // namespace mlir
5812MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MulFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MulFOp>::id = {}; } }

5814namespace mlir {
5815namespace arith {

5817//===----------------------------------------------------------------------===//
5818// ::mlir::arith::MulIOp definitions
5819//===----------------------------------------------------------------------===//

5821MulIOpAdaptor::MulIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.muli", odsAttrs.getContext());
5823}

5825MulIOpAdaptor::MulIOpAdaptor(MulIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange MulIOpAdaptor::getOperands() {
return odsOperands;
5829}

5831std::pair<unsigned, unsigned> MulIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5833}

:mlir::ValueRange MulIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
5839}

:mlir::Value MulIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
5843}

:mlir::Value MulIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
5847}

:mlir::DictionaryAttr MulIOpAdaptor::getAttributes() {
return odsAttrs;
5851}

:mlir::LogicalResult MulIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
5855}

5857std::pair<unsigned, unsigned> MulIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
5859}

:mlir::Operation::operand_range MulIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
5865}

:mlir::Value MulIOp::getLhs() {
return *getODSOperands(0).begin();
5869}

:mlir::Value MulIOp::getRhs() {
return *getODSOperands(1).begin();
5873}

:mlir::MutableOperandRange MulIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5879}

:mlir::MutableOperandRange MulIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
5885}

5887std::pair<unsigned, unsigned> MulIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
5889}

:mlir::Operation::result_range MulIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
5895}

:mlir::Value MulIOp::getResult() {
return *getODSResults(0).begin();
5899}

5901void MulIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
5905}

5907void MulIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5910, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5912}

5914void MulIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5915, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 5918, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
5920}

5922void MulIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

5927}

5929void MulIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

5934}

:mlir::LogicalResult MulIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
5962}

:mlir::LogicalResult MulIOp::verifyInvariants() {
return verifyInvariantsImpl();
5966}

:mlir::ParseResult MulIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
6004}

6006void MulIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
6022}

6024void MulIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
6025}

6027} // namespace arith
6028} // namespace mlir
6029MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::MulIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::MulIOp>::id = {}; } }

6031namespace mlir {
6032namespace arith {

6034//===----------------------------------------------------------------------===//
6035// ::mlir::arith::NegFOp definitions
6036//===----------------------------------------------------------------------===//

6038NegFOpAdaptor::NegFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.negf", odsAttrs.getContext());
6040}

6042NegFOpAdaptor::NegFOpAdaptor(NegFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange NegFOpAdaptor::getOperands() {
return odsOperands;
6046}

6048std::pair<unsigned, unsigned> NegFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6050}

:mlir::ValueRange NegFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
6056}

:mlir::Value NegFOpAdaptor::getOperand() {
return *getODSOperands(0).begin();
6060}

:mlir::DictionaryAttr NegFOpAdaptor::getAttributes() {
return odsAttrs;
6064}

:mlir::LogicalResult NegFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
6068}

6070std::pair<unsigned, unsigned> NegFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6072}

:mlir::Operation::operand_range NegFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
6078}

:mlir::Value NegFOp::getOperand() {
return *getODSOperands(0).begin();
6082}

:mlir::MutableOperandRange NegFOp::getOperandMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6088}

6090std::pair<unsigned, unsigned> NegFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
6092}

:mlir::Operation::result_range NegFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
6098}

:mlir::Value NegFOp::getResult() {
return *getODSResults(0).begin();
6102}

6104void NegFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
odsState.addOperands(operand);
odsState.addTypes(result);
6107}

6109void NegFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand) {
odsState.addOperands(operand);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6111, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6113}

6115void NegFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6116, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6119, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6121}

6123void NegFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand) {
odsState.addOperands(operand);
odsState.addTypes({operand.getType()});

6127}

6129void NegFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

6134}

:mlir::LogicalResult NegFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
6156}

:mlir::LogicalResult NegFOp::verifyInvariants() {
return verifyInvariantsImpl();
6160}

:mlir::ParseResult NegFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand operandRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> operandOperands(operandRawOperands);  ::llvm::SMLoc operandOperandsLoc;
(void)operandOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

operandOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(operandRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(operandOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
6187}

6189void NegFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getOperand();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
6202}

6204void NegFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
6205}

6207} // namespace arith
6208} // namespace mlir
6209MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::NegFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::NegFOp>::id = {}; } }

6211namespace mlir {
6212namespace arith {

6214//===----------------------------------------------------------------------===//
6215// ::mlir::arith::OrIOp definitions
6216//===----------------------------------------------------------------------===//

6218OrIOpAdaptor::OrIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.ori", odsAttrs.getContext());
6220}

6222OrIOpAdaptor::OrIOpAdaptor(OrIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange OrIOpAdaptor::getOperands() {
return odsOperands;
6226}

6228std::pair<unsigned, unsigned> OrIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6230}

:mlir::ValueRange OrIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
6236}

:mlir::Value OrIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
6240}

:mlir::Value OrIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
6244}

:mlir::DictionaryAttr OrIOpAdaptor::getAttributes() {
return odsAttrs;
6248}

:mlir::LogicalResult OrIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
6252}

6254std::pair<unsigned, unsigned> OrIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6256}

:mlir::Operation::operand_range OrIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
6262}

:mlir::Value OrIOp::getLhs() {
return *getODSOperands(0).begin();
6266}

:mlir::Value OrIOp::getRhs() {
return *getODSOperands(1).begin();
6270}

:mlir::MutableOperandRange OrIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6276}

:mlir::MutableOperandRange OrIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6282}

6284std::pair<unsigned, unsigned> OrIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
6286}

:mlir::Operation::result_range OrIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
6292}

:mlir::Value OrIOp::getResult() {
return *getODSResults(0).begin();
6296}

6298void OrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
6302}

6304void OrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6307, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6309}

6311void OrIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6312, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6315, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6317}

6319void OrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

6324}

6326void OrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

6331}

:mlir::LogicalResult OrIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
6359}

:mlir::LogicalResult OrIOp::verifyInvariants() {
return verifyInvariantsImpl();
6363}

:mlir::ParseResult OrIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
6401}

6403void OrIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
6419}

6421void OrIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
6422}

6424} // namespace arith
6425} // namespace mlir
6426MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::OrIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::OrIOp>::id = {}; } }

6428namespace mlir {
6429namespace arith {

6431//===----------------------------------------------------------------------===//
6432// ::mlir::arith::RemFOp definitions
6433//===----------------------------------------------------------------------===//

6435RemFOpAdaptor::RemFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.remf", odsAttrs.getContext());
6437}

6439RemFOpAdaptor::RemFOpAdaptor(RemFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange RemFOpAdaptor::getOperands() {
return odsOperands;
6443}

6445std::pair<unsigned, unsigned> RemFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6447}

:mlir::ValueRange RemFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
6453}

:mlir::Value RemFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
6457}

:mlir::Value RemFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
6461}

:mlir::DictionaryAttr RemFOpAdaptor::getAttributes() {
return odsAttrs;
6465}

:mlir::LogicalResult RemFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
6469}

6471std::pair<unsigned, unsigned> RemFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6473}

:mlir::Operation::operand_range RemFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
6479}

:mlir::Value RemFOp::getLhs() {
return *getODSOperands(0).begin();
6483}

:mlir::Value RemFOp::getRhs() {
return *getODSOperands(1).begin();
6487}

:mlir::MutableOperandRange RemFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6493}

:mlir::MutableOperandRange RemFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6499}

6501std::pair<unsigned, unsigned> RemFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
6503}

:mlir::Operation::result_range RemFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
6509}

:mlir::Value RemFOp::getResult() {
return *getODSResults(0).begin();
6513}

6515void RemFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
6519}

6521void RemFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6524, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6526}

6528void RemFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6529, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6532, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6534}

6536void RemFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

6541}

6543void RemFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

6548}

:mlir::LogicalResult RemFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
6576}

:mlir::LogicalResult RemFOp::verifyInvariants() {
return verifyInvariantsImpl();
6580}

:mlir::ParseResult RemFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
6618}

6620void RemFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
6636}

6638void RemFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
6639}

6641} // namespace arith
6642} // namespace mlir
6643MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::RemFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::RemFOp>::id = {}; } }

6645namespace mlir {
6646namespace arith {

6648//===----------------------------------------------------------------------===//
6649// ::mlir::arith::RemSIOp definitions
6650//===----------------------------------------------------------------------===//

6652RemSIOpAdaptor::RemSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.remsi", odsAttrs.getContext());
6654}

6656RemSIOpAdaptor::RemSIOpAdaptor(RemSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange RemSIOpAdaptor::getOperands() {
return odsOperands;
6660}

6662std::pair<unsigned, unsigned> RemSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6664}

:mlir::ValueRange RemSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
6670}

:mlir::Value RemSIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
6674}

:mlir::Value RemSIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
6678}

:mlir::DictionaryAttr RemSIOpAdaptor::getAttributes() {
return odsAttrs;
6682}

:mlir::LogicalResult RemSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
6686}

6688std::pair<unsigned, unsigned> RemSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6690}

:mlir::Operation::operand_range RemSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
6696}

:mlir::Value RemSIOp::getLhs() {
return *getODSOperands(0).begin();
6700}

:mlir::Value RemSIOp::getRhs() {
return *getODSOperands(1).begin();
6704}

:mlir::MutableOperandRange RemSIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6710}

:mlir::MutableOperandRange RemSIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6716}

6718std::pair<unsigned, unsigned> RemSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
6720}

:mlir::Operation::result_range RemSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
6726}

:mlir::Value RemSIOp::getResult() {
return *getODSResults(0).begin();
6730}

6732void RemSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
6736}

6738void RemSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6741, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6743}

6745void RemSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6746, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6749, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6751}

6753void RemSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

6758}

6760void RemSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

6765}

:mlir::LogicalResult RemSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
6793}

:mlir::LogicalResult RemSIOp::verifyInvariants() {
return verifyInvariantsImpl();
6797}

:mlir::ParseResult RemSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
6835}

6837void RemSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
6853}

6855void RemSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
6856}

6858} // namespace arith
6859} // namespace mlir
6860MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::RemSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::RemSIOp>::id = {}; } }

6862namespace mlir {
6863namespace arith {

6865//===----------------------------------------------------------------------===//
6866// ::mlir::arith::RemUIOp definitions
6867//===----------------------------------------------------------------------===//

6869RemUIOpAdaptor::RemUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.remui", odsAttrs.getContext());
6871}

6873RemUIOpAdaptor::RemUIOpAdaptor(RemUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange RemUIOpAdaptor::getOperands() {
return odsOperands;
6877}

6879std::pair<unsigned, unsigned> RemUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6881}

:mlir::ValueRange RemUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
6887}

:mlir::Value RemUIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
6891}

:mlir::Value RemUIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
6895}

:mlir::DictionaryAttr RemUIOpAdaptor::getAttributes() {
return odsAttrs;
6899}

:mlir::LogicalResult RemUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
6903}

6905std::pair<unsigned, unsigned> RemUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
6907}

:mlir::Operation::operand_range RemUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
6913}

:mlir::Value RemUIOp::getLhs() {
return *getODSOperands(0).begin();
6917}

:mlir::Value RemUIOp::getRhs() {
return *getODSOperands(1).begin();
6921}

:mlir::MutableOperandRange RemUIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6927}

:mlir::MutableOperandRange RemUIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
6933}

6935std::pair<unsigned, unsigned> RemUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
6937}

:mlir::Operation::result_range RemUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
6943}

:mlir::Value RemUIOp::getResult() {
return *getODSResults(0).begin();
6947}

6949void RemUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
6953}

6955void RemUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6958, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6960}

6962void RemUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6963, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 6966, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
6968}

6970void RemUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

6975}

6977void RemUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

6982}

:mlir::LogicalResult RemUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
7010}

:mlir::LogicalResult RemUIOp::verifyInvariants() {
return verifyInvariantsImpl();
7014}

:mlir::ParseResult RemUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
7052}

7054void RemUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
7070}

7072void RemUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
7073}

7075} // namespace arith
7076} // namespace mlir
7077MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::RemUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::RemUIOp>::id = {}; } }

7079namespace mlir {
7080namespace arith {

7082//===----------------------------------------------------------------------===//
7083// ::mlir::arith::SIToFPOp definitions
7084//===----------------------------------------------------------------------===//

7086SIToFPOpAdaptor::SIToFPOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.sitofp", odsAttrs.getContext());
7088}

7090SIToFPOpAdaptor::SIToFPOpAdaptor(SIToFPOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange SIToFPOpAdaptor::getOperands() {
return odsOperands;
7094}

7096std::pair<unsigned, unsigned> SIToFPOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7098}

:mlir::ValueRange SIToFPOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
7104}

:mlir::Value SIToFPOpAdaptor::getIn() {
return *getODSOperands(0).begin();
7108}

:mlir::DictionaryAttr SIToFPOpAdaptor::getAttributes() {
return odsAttrs;
7112}

:mlir::LogicalResult SIToFPOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
7116}

7118std::pair<unsigned, unsigned> SIToFPOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7120}

:mlir::Operation::operand_range SIToFPOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
7126}

:mlir::Value SIToFPOp::getIn() {
return *getODSOperands(0).begin();
7130}

:mlir::MutableOperandRange SIToFPOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7136}

7138std::pair<unsigned, unsigned> SIToFPOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
7140}

:mlir::Operation::result_range SIToFPOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
7146}

:mlir::Value SIToFPOp::getOut() {
return *getODSResults(0).begin();
7150}

7152void SIToFPOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
7155}

7157void SIToFPOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7159, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7161}

7163void SIToFPOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7164, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7167, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7169}

:mlir::LogicalResult SIToFPOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
7191}

:mlir::LogicalResult SIToFPOp::verifyInvariants() {
return verifyInvariantsImpl();
7195}

:mlir::ParseResult SIToFPOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
7233}

7235void SIToFPOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
7257}

7259void SIToFPOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
7260}

7262} // namespace arith
7263} // namespace mlir
7264MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::SIToFPOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::SIToFPOp>::id = {}; } }

7266namespace mlir {
7267namespace arith {

7269//===----------------------------------------------------------------------===//
7270// ::mlir::arith::ShLIOp definitions
7271//===----------------------------------------------------------------------===//

7273ShLIOpAdaptor::ShLIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.shli", odsAttrs.getContext());
7275}

7277ShLIOpAdaptor::ShLIOpAdaptor(ShLIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange ShLIOpAdaptor::getOperands() {
return odsOperands;
7281}

7283std::pair<unsigned, unsigned> ShLIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7285}

:mlir::ValueRange ShLIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
7291}

:mlir::Value ShLIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
7295}

:mlir::Value ShLIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
7299}

:mlir::DictionaryAttr ShLIOpAdaptor::getAttributes() {
return odsAttrs;
7303}

:mlir::LogicalResult ShLIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
7307}

7309std::pair<unsigned, unsigned> ShLIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7311}

:mlir::Operation::operand_range ShLIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
7317}

:mlir::Value ShLIOp::getLhs() {
return *getODSOperands(0).begin();
7321}

:mlir::Value ShLIOp::getRhs() {
return *getODSOperands(1).begin();
7325}

:mlir::MutableOperandRange ShLIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7331}

:mlir::MutableOperandRange ShLIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7337}

7339std::pair<unsigned, unsigned> ShLIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
7341}

:mlir::Operation::result_range ShLIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
7347}

:mlir::Value ShLIOp::getResult() {
return *getODSResults(0).begin();
7351}

7353void ShLIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
7357}

7359void ShLIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7362, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7364}

7366void ShLIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7367, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7370, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7372}

7374void ShLIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

7379}

7381void ShLIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

7386}

:mlir::LogicalResult ShLIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
7414}

:mlir::LogicalResult ShLIOp::verifyInvariants() {
return verifyInvariantsImpl();
7418}

:mlir::ParseResult ShLIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
7456}

7458void ShLIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
7474}

7476void ShLIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
7477}

7479} // namespace arith
7480} // namespace mlir
7481MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::ShLIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::ShLIOp>::id = {}; } }

7483namespace mlir {
7484namespace arith {

7486//===----------------------------------------------------------------------===//
7487// ::mlir::arith::ShRSIOp definitions
7488//===----------------------------------------------------------------------===//

7490ShRSIOpAdaptor::ShRSIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.shrsi", odsAttrs.getContext());
7492}

7494ShRSIOpAdaptor::ShRSIOpAdaptor(ShRSIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange ShRSIOpAdaptor::getOperands() {
return odsOperands;
7498}

7500std::pair<unsigned, unsigned> ShRSIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7502}

:mlir::ValueRange ShRSIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
7508}

:mlir::Value ShRSIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
7512}

:mlir::Value ShRSIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
7516}

:mlir::DictionaryAttr ShRSIOpAdaptor::getAttributes() {
return odsAttrs;
7520}

:mlir::LogicalResult ShRSIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
7524}

7526std::pair<unsigned, unsigned> ShRSIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7528}

:mlir::Operation::operand_range ShRSIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
7534}

:mlir::Value ShRSIOp::getLhs() {
return *getODSOperands(0).begin();
7538}

:mlir::Value ShRSIOp::getRhs() {
return *getODSOperands(1).begin();
7542}

:mlir::MutableOperandRange ShRSIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7548}

:mlir::MutableOperandRange ShRSIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7554}

7556std::pair<unsigned, unsigned> ShRSIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
7558}

:mlir::Operation::result_range ShRSIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
7564}

:mlir::Value ShRSIOp::getResult() {
return *getODSResults(0).begin();
7568}

7570void ShRSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
7574}

7576void ShRSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7579, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7581}

7583void ShRSIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7584, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7587, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7589}

7591void ShRSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

7596}

7598void ShRSIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

7603}

:mlir::LogicalResult ShRSIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
7631}

:mlir::LogicalResult ShRSIOp::verifyInvariants() {
return verifyInvariantsImpl();
7635}

:mlir::ParseResult ShRSIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
7673}

7675void ShRSIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
7691}

7693void ShRSIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
7694}

7696} // namespace arith
7697} // namespace mlir
7698MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::ShRSIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::ShRSIOp>::id = {}; } }

7700namespace mlir {
7701namespace arith {

7703//===----------------------------------------------------------------------===//
7704// ::mlir::arith::ShRUIOp definitions
7705//===----------------------------------------------------------------------===//

7707ShRUIOpAdaptor::ShRUIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.shrui", odsAttrs.getContext());
7709}

7711ShRUIOpAdaptor::ShRUIOpAdaptor(ShRUIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange ShRUIOpAdaptor::getOperands() {
return odsOperands;
7715}

7717std::pair<unsigned, unsigned> ShRUIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7719}

:mlir::ValueRange ShRUIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
7725}

:mlir::Value ShRUIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
7729}

:mlir::Value ShRUIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
7733}

:mlir::DictionaryAttr ShRUIOpAdaptor::getAttributes() {
return odsAttrs;
7737}

:mlir::LogicalResult ShRUIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
7741}

7743std::pair<unsigned, unsigned> ShRUIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7745}

:mlir::Operation::operand_range ShRUIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
7751}

:mlir::Value ShRUIOp::getLhs() {
return *getODSOperands(0).begin();
7755}

:mlir::Value ShRUIOp::getRhs() {
return *getODSOperands(1).begin();
7759}

:mlir::MutableOperandRange ShRUIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7765}

:mlir::MutableOperandRange ShRUIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7771}

7773std::pair<unsigned, unsigned> ShRUIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
7775}

:mlir::Operation::result_range ShRUIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
7781}

:mlir::Value ShRUIOp::getResult() {
return *getODSResults(0).begin();
7785}

7787void ShRUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
7791}

7793void ShRUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7796, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7798}

7800void ShRUIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7801, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 7804, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
7806}

7808void ShRUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

7813}

7815void ShRUIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

7820}

:mlir::LogicalResult ShRUIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
7848}

:mlir::LogicalResult ShRUIOp::verifyInvariants() {
return verifyInvariantsImpl();
7852}

:mlir::ParseResult ShRUIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
7890}

7892void ShRUIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
7908}

7910void ShRUIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
7911}

7913} // namespace arith
7914} // namespace mlir
7915MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::ShRUIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::ShRUIOp>::id = {}; } }

7917namespace mlir {
7918namespace arith {

7920//===----------------------------------------------------------------------===//
7921// ::mlir::arith::SubFOp definitions
7922//===----------------------------------------------------------------------===//

7924SubFOpAdaptor::SubFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.subf", odsAttrs.getContext());
7926}

7928SubFOpAdaptor::SubFOpAdaptor(SubFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange SubFOpAdaptor::getOperands() {
return odsOperands;
7932}

7934std::pair<unsigned, unsigned> SubFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7936}

:mlir::ValueRange SubFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
7942}

:mlir::Value SubFOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
7946}

:mlir::Value SubFOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
7950}

:mlir::DictionaryAttr SubFOpAdaptor::getAttributes() {
return odsAttrs;
7954}

:mlir::LogicalResult SubFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
7958}

7960std::pair<unsigned, unsigned> SubFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
7962}

:mlir::Operation::operand_range SubFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
7968}

:mlir::Value SubFOp::getLhs() {
return *getODSOperands(0).begin();
7972}

:mlir::Value SubFOp::getRhs() {
return *getODSOperands(1).begin();
7976}

:mlir::MutableOperandRange SubFOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7982}

:mlir::MutableOperandRange SubFOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
7988}

7990std::pair<unsigned, unsigned> SubFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
7992}

:mlir::Operation::result_range SubFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
7998}

:mlir::Value SubFOp::getResult() {
return *getODSResults(0).begin();
8002}

8004void SubFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
8008}

8010void SubFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8013, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8015}

8017void SubFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8018, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8021, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8023}

8025void SubFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

8030}

8032void SubFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

8037}

:mlir::LogicalResult SubFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
8065}

:mlir::LogicalResult SubFOp::verifyInvariants() {
return verifyInvariantsImpl();
8069}

:mlir::ParseResult SubFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
8107}

8109void SubFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
8125}

8127void SubFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
8128}

8130} // namespace arith
8131} // namespace mlir
8132MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::SubFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::SubFOp>::id = {}; } }

8134namespace mlir {
8135namespace arith {

8137//===----------------------------------------------------------------------===//
8138// ::mlir::arith::SubIOp definitions
8139//===----------------------------------------------------------------------===//

8141SubIOpAdaptor::SubIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.subi", odsAttrs.getContext());
8143}

8145SubIOpAdaptor::SubIOpAdaptor(SubIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange SubIOpAdaptor::getOperands() {
return odsOperands;
8149}

8151std::pair<unsigned, unsigned> SubIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8153}

:mlir::ValueRange SubIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
8159}

:mlir::Value SubIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
8163}

:mlir::Value SubIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
8167}

:mlir::DictionaryAttr SubIOpAdaptor::getAttributes() {
return odsAttrs;
8171}

:mlir::LogicalResult SubIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
8175}

8177std::pair<unsigned, unsigned> SubIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8179}

:mlir::Operation::operand_range SubIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
8185}

:mlir::Value SubIOp::getLhs() {
return *getODSOperands(0).begin();
8189}

:mlir::Value SubIOp::getRhs() {
return *getODSOperands(1).begin();
8193}

:mlir::MutableOperandRange SubIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
8199}

:mlir::MutableOperandRange SubIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
8205}

8207std::pair<unsigned, unsigned> SubIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
8209}

:mlir::Operation::result_range SubIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
8215}

:mlir::Value SubIOp::getResult() {
return *getODSResults(0).begin();
8219}

8221void SubIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
8225}

8227void SubIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8230, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8232}

8234void SubIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8235, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8238, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8240}

8242void SubIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

8247}

8249void SubIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

8254}

:mlir::LogicalResult SubIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
8282}

:mlir::LogicalResult SubIOp::verifyInvariants() {
return verifyInvariantsImpl();
8286}

:mlir::ParseResult SubIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
8324}

8326void SubIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
8342}

8344void SubIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
8345}

8347} // namespace arith
8348} // namespace mlir
8349MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::SubIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::SubIOp>::id = {}; } }

8351namespace mlir {
8352namespace arith {

8354//===----------------------------------------------------------------------===//
8355// ::mlir::arith::TruncFOp definitions
8356//===----------------------------------------------------------------------===//

8358TruncFOpAdaptor::TruncFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.truncf", odsAttrs.getContext());
8360}

8362TruncFOpAdaptor::TruncFOpAdaptor(TruncFOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange TruncFOpAdaptor::getOperands() {
return odsOperands;
8366}

8368std::pair<unsigned, unsigned> TruncFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8370}

:mlir::ValueRange TruncFOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
8376}

:mlir::Value TruncFOpAdaptor::getIn() {
return *getODSOperands(0).begin();
8380}

:mlir::DictionaryAttr TruncFOpAdaptor::getAttributes() {
return odsAttrs;
8384}

:mlir::LogicalResult TruncFOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
8388}

8390std::pair<unsigned, unsigned> TruncFOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8392}

:mlir::Operation::operand_range TruncFOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
8398}

:mlir::Value TruncFOp::getIn() {
return *getODSOperands(0).begin();
8402}

:mlir::MutableOperandRange TruncFOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
8408}

8410std::pair<unsigned, unsigned> TruncFOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
8412}

:mlir::Operation::result_range TruncFOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
8418}

:mlir::Value TruncFOp::getOut() {
return *getODSResults(0).begin();
8422}

8424void TruncFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
8427}

8429void TruncFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8431, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8433}

8435void TruncFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8436, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8439, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8441}

:mlir::LogicalResult TruncFOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
8463}

:mlir::LogicalResult TruncFOp::verifyInvariants() {
if(::mlir::succeeded(verifyInvariantsImpl()) && ::mlir::succeeded(verify()))
  return ::mlir::success();
return ::mlir::failure();
8469}

:mlir::ParseResult TruncFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
8507}

8509void TruncFOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
8531}

8533void TruncFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
8534}

8536} // namespace arith
8537} // namespace mlir
8538MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::TruncFOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::TruncFOp>::id = {}; } }

8540namespace mlir {
8541namespace arith {

8543//===----------------------------------------------------------------------===//
8544// ::mlir::arith::TruncIOp definitions
8545//===----------------------------------------------------------------------===//

8547TruncIOpAdaptor::TruncIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.trunci", odsAttrs.getContext());
8549}

8551TruncIOpAdaptor::TruncIOpAdaptor(TruncIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange TruncIOpAdaptor::getOperands() {
return odsOperands;
8555}

8557std::pair<unsigned, unsigned> TruncIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8559}

:mlir::ValueRange TruncIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
8565}

:mlir::Value TruncIOpAdaptor::getIn() {
return *getODSOperands(0).begin();
8569}

:mlir::DictionaryAttr TruncIOpAdaptor::getAttributes() {
return odsAttrs;
8573}

:mlir::LogicalResult TruncIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
8577}

8579std::pair<unsigned, unsigned> TruncIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8581}

:mlir::Operation::operand_range TruncIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
8587}

:mlir::Value TruncIOp::getIn() {
return *getODSOperands(0).begin();
8591}

:mlir::MutableOperandRange TruncIOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
8597}

8599std::pair<unsigned, unsigned> TruncIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
8601}

:mlir::Operation::result_range TruncIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
8607}

:mlir::Value TruncIOp::getOut() {
return *getODSResults(0).begin();
8611}

8613void TruncIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
8616}

8618void TruncIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8620, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8622}

8624void TruncIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8625, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8628, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8630}

:mlir::LogicalResult TruncIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
8652}

:mlir::LogicalResult TruncIOp::verifyInvariants() {
if(::mlir::succeeded(verifyInvariantsImpl()) && ::mlir::succeeded(verify()))
  return ::mlir::success();
return ::mlir::failure();
8658}

:mlir::ParseResult TruncIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
8696}

8698void TruncIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
8720}

8722void TruncIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
8723}

8725} // namespace arith
8726} // namespace mlir
8727MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::TruncIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::TruncIOp>::id = {}; } }

8729namespace mlir {
8730namespace arith {

8732//===----------------------------------------------------------------------===//
8733// ::mlir::arith::UIToFPOp definitions
8734//===----------------------------------------------------------------------===//

8736UIToFPOpAdaptor::UIToFPOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.uitofp", odsAttrs.getContext());
8738}

8740UIToFPOpAdaptor::UIToFPOpAdaptor(UIToFPOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange UIToFPOpAdaptor::getOperands() {
return odsOperands;
8744}

8746std::pair<unsigned, unsigned> UIToFPOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8748}

:mlir::ValueRange UIToFPOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
8754}

:mlir::Value UIToFPOpAdaptor::getIn() {
return *getODSOperands(0).begin();
8758}

:mlir::DictionaryAttr UIToFPOpAdaptor::getAttributes() {
return odsAttrs;
8762}

:mlir::LogicalResult UIToFPOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
8766}

8768std::pair<unsigned, unsigned> UIToFPOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8770}

:mlir::Operation::operand_range UIToFPOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
8776}

:mlir::Value UIToFPOp::getIn() {
return *getODSOperands(0).begin();
8780}

:mlir::MutableOperandRange UIToFPOp::getInMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
8786}

8788std::pair<unsigned, unsigned> UIToFPOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
8790}

:mlir::Operation::result_range UIToFPOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
8796}

:mlir::Value UIToFPOp::getOut() {
return *getODSResults(0).begin();
8800}

8802void UIToFPOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type out, ::mlir::Value in) {
odsState.addOperands(in);
odsState.addTypes(out);
8805}

8807void UIToFPOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value in) {
odsState.addOperands(in);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8809, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8811}

8813void UIToFPOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 1u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 1u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 1u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8814, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 8817, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
8819}

:mlir::LogicalResult UIToFPOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps7(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps0(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
8841}

:mlir::LogicalResult UIToFPOp::verifyInvariants() {
return verifyInvariantsImpl();
8845}

:mlir::ParseResult UIToFPOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand inRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> inOperands(inRawOperands);  ::llvm::SMLoc inOperandsLoc;
(void)inOperandsLoc;
::mlir::Type inRawTypes[1];
::llvm::ArrayRef<::mlir::Type> inTypes(inRawTypes);
::mlir::Type outRawTypes[1];
::llvm::ArrayRef<::mlir::Type> outTypes(outRawTypes);

inOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(inRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  inRawTypes[0] = type;
}
if (parser.parseKeyword("to"))
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  outRawTypes[0] = type;
}
result.addTypes(outTypes);
if (parser.resolveOperands(inOperands, inTypes, inOperandsLoc, result.operands))
  return ::mlir::failure();
return ::mlir::success();
8883}

8885void UIToFPOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getIn();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getIn().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
_odsPrinter << ' ' << "to";
_odsPrinter << ' ';
{
  auto type = getOut().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
8907}

8909void UIToFPOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
8910}

8912} // namespace arith
8913} // namespace mlir
8914MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::UIToFPOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::UIToFPOp>::id = {}; } }

8916namespace mlir {
8917namespace arith {

8919//===----------------------------------------------------------------------===//
8920// ::mlir::arith::XOrIOp definitions
8921//===----------------------------------------------------------------------===//

8923XOrIOpAdaptor::XOrIOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.xori", odsAttrs.getContext());
8925}

8927XOrIOpAdaptor::XOrIOpAdaptor(XOrIOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange XOrIOpAdaptor::getOperands() {
return odsOperands;
8931}

8933std::pair<unsigned, unsigned> XOrIOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8935}

:mlir::ValueRange XOrIOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
8941}

:mlir::Value XOrIOpAdaptor::getLhs() {
return *getODSOperands(0).begin();
8945}

:mlir::Value XOrIOpAdaptor::getRhs() {
return *getODSOperands(1).begin();
8949}

:mlir::DictionaryAttr XOrIOpAdaptor::getAttributes() {
return odsAttrs;
8953}

:mlir::LogicalResult XOrIOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
8957}

8959std::pair<unsigned, unsigned> XOrIOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
8961}

:mlir::Operation::operand_range XOrIOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
8967}

:mlir::Value XOrIOp::getLhs() {
return *getODSOperands(0).begin();
8971}

:mlir::Value XOrIOp::getRhs() {
return *getODSOperands(1).begin();
8975}

:mlir::MutableOperandRange XOrIOp::getLhsMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
8981}

:mlir::MutableOperandRange XOrIOp::getRhsMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
8987}

8989std::pair<unsigned, unsigned> XOrIOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
8991}

:mlir::Operation::result_range XOrIOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
8997}

:mlir::Value XOrIOp::getResult() {
return *getODSResults(0).begin();
9001}

9003void XOrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes(result);
9007}

9009void XOrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9012, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
9014}

9016void XOrIOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 2u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 2u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 2u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9017, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9020, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
9022}

9024void XOrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs) {
odsState.addOperands(lhs);
odsState.addOperands(rhs);
odsState.addTypes({lhs.getType()});

9029}

9031void XOrIOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
odsState.addOperands(operands);
odsState.addAttributes(attributes);
odsState.addTypes({operands[0].getType()});

9036}

:mlir::LogicalResult XOrIOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps1(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
return ::mlir::success();
9064}

:mlir::LogicalResult XOrIOp::verifyInvariants() {
return verifyInvariantsImpl();
9068}

:mlir::ParseResult XOrIOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
::mlir::OpAsmParser::UnresolvedOperand lhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> lhsOperands(lhsRawOperands);  ::llvm::SMLoc lhsOperandsLoc;
(void)lhsOperandsLoc;
::mlir::OpAsmParser::UnresolvedOperand rhsRawOperands[1];
::llvm::ArrayRef<::mlir::OpAsmParser::UnresolvedOperand> rhsOperands(rhsRawOperands);  ::llvm::SMLoc rhsOperandsLoc;
(void)rhsOperandsLoc;
::mlir::Type resultRawTypes[1];
::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

lhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(lhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseComma())
  return ::mlir::failure();

rhsOperandsLoc = parser.getCurrentLocation();
if (parser.parseOperand(rhsRawOperands[0]))
  return ::mlir::failure();
if (parser.parseOptionalAttrDict(result.attributes))
  return ::mlir::failure();
if (parser.parseColon())
  return ::mlir::failure();

{
  ::mlir::Type type;
  if (parser.parseCustomTypeWithFallback(type))
    return ::mlir::failure();
  resultRawTypes[0] = type;
}
result.addTypes(resultTypes);
if (parser.resolveOperands(lhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
if (parser.resolveOperands(rhsOperands, resultTypes[0], result.operands))
  return ::mlir::failure();
return ::mlir::success();
9106}

9108void XOrIOp::print(::mlir::OpAsmPrinter &_odsPrinter) {
_odsPrinter << ' ';
_odsPrinter << getLhs();
_odsPrinter << ",";
_odsPrinter << ' ';
_odsPrinter << getRhs();
_odsPrinter.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{});
_odsPrinter << ' ' << ":";
_odsPrinter << ' ';
{
  auto type = getResult().getType();
  if (auto validType = type.dyn_cast<::mlir::Type>())
    _odsPrinter.printStrippedAttrOrType(validType);
 else
   _odsPrinter << type;
}
9124}

9126void XOrIOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
9127}

9129} // namespace arith
9130} // namespace mlir
9131MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::XOrIOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::XOrIOp>::id = {}; } }

9133namespace mlir {
9134namespace arith {

9136//===----------------------------------------------------------------------===//
9137// ::mlir::arith::SelectOp definitions
9138//===----------------------------------------------------------------------===//

9140SelectOpAdaptor::SelectOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs, ::mlir::RegionRange regions) : odsOperands(values), odsAttrs(attrs), odsRegions(regions) {  if (odsAttrs)
  odsOpName.emplace("arith.select", odsAttrs.getContext());
9142}

9144SelectOpAdaptor::SelectOpAdaptor(SelectOp op) : odsOperands(op->getOperands()), odsAttrs(op->getAttrDictionary()), odsRegions(op->getRegions()), odsOpName(op->getName()) {}

:mlir::ValueRange SelectOpAdaptor::getOperands() {
return odsOperands;
9148}

9150std::pair<unsigned, unsigned> SelectOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
9152}

:mlir::ValueRange SelectOpAdaptor::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(odsOperands.begin(), valueRange.first),
         std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
9158}

:mlir::Value SelectOpAdaptor::getCondition() {
return *getODSOperands(0).begin();
9162}

:mlir::Value SelectOpAdaptor::getTrueValue() {
return *getODSOperands(1).begin();
9166}

:mlir::Value SelectOpAdaptor::getFalseValue() {
return *getODSOperands(2).begin();
9170}

:mlir::DictionaryAttr SelectOpAdaptor::getAttributes() {
return odsAttrs;
9174}

:mlir::LogicalResult SelectOpAdaptor::verify(::mlir::Location loc) {
return ::mlir::success();
9178}

9180std::pair<unsigned, unsigned> SelectOp::getODSOperandIndexAndLength(unsigned index) {
return {index, 1};
9182}

:mlir::Operation::operand_range SelectOp::getODSOperands(unsigned index) {
auto valueRange = getODSOperandIndexAndLength(index);
return {std::next(getOperation()->operand_begin(), valueRange.first),
         std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
9188}

:mlir::Value SelectOp::getCondition() {
return *getODSOperands(0).begin();
9192}

:mlir::Value SelectOp::getTrueValue() {
return *getODSOperands(1).begin();
9196}

:mlir::Value SelectOp::getFalseValue() {
return *getODSOperands(2).begin();
9200}

:mlir::MutableOperandRange SelectOp::getConditionMutable() {
auto range = getODSOperandIndexAndLength(0);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
9206}

:mlir::MutableOperandRange SelectOp::getTrueValueMutable() {
auto range = getODSOperandIndexAndLength(1);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
9212}

:mlir::MutableOperandRange SelectOp::getFalseValueMutable() {
auto range = getODSOperandIndexAndLength(2);
auto mutableRange = ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
return mutableRange;
9218}

9220std::pair<unsigned, unsigned> SelectOp::getODSResultIndexAndLength(unsigned index) {
return {index, 1};
9222}

:mlir::Operation::result_range SelectOp::getODSResults(unsigned index) {
auto valueRange = getODSResultIndexAndLength(index);
return {std::next(getOperation()->result_begin(), valueRange.first),
         std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
9228}

:mlir::Value SelectOp::getResult() {
return *getODSResults(0).begin();
9232}

9234void SelectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value condition, ::mlir::Value true_value, ::mlir::Value false_value) {
odsState.addOperands(condition);
odsState.addOperands(true_value);
odsState.addOperands(false_value);
odsState.addTypes(result);
9239}

9241void SelectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value condition, ::mlir::Value true_value, ::mlir::Value false_value) {
odsState.addOperands(condition);
odsState.addOperands(true_value);
odsState.addOperands(false_value);

      ::llvm::SmallVector<::mlir::Type, 2> inferredReturnTypes;
      if (::mlir::succeeded(SelectOp::inferReturnTypes(odsBuilder.getContext(),
                    odsState.location, odsState.operands,
                    odsState.attributes.getDictionary(odsState.getContext()),
                    /*regions=*/{}, inferredReturnTypes)))
        odsState.addTypes(inferredReturnTypes);
      else
        ::llvm::report_fatal_error("Failed to infer result type(s).");
9254}

9256void SelectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::Value true_value, ::mlir::Value false_value) {
odsState.addOperands(condition);
odsState.addOperands(true_value);
odsState.addOperands(false_value);
assert(resultTypes.size() == 1u && "mismatched number of results")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of results") ? void (0) : __assert_fail (
"resultTypes.size() == 1u && \"mismatched number of results\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9260, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
9262}

9264void SelectOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 3u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 3u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 3u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9265, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);
assert(resultTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (resultTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("resultTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9268, __extension__ __PRETTY_FUNCTION__));
odsState.addTypes(resultTypes);
9270}

9272void SelectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
assert(operands.size() == 3u && "mismatched number of parameters")(static_cast <bool> (operands.size() == 3u && "mismatched number of parameters"
) ? void (0) : __assert_fail ("operands.size() == 3u && \"mismatched number of parameters\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9273, __extension__ __PRETTY_FUNCTION__));
odsState.addOperands(operands);
odsState.addAttributes(attributes);

::mlir::SmallVector<::mlir::Type, 2> inferredReturnTypes;
if (::mlir::succeeded(SelectOp::inferReturnTypes(odsBuilder.getContext(),
        odsState.location, operands,
        odsState.attributes.getDictionary(odsState.getContext()),
        odsState.regions, inferredReturnTypes))) {
  assert(inferredReturnTypes.size() == 1u && "mismatched number of return types")(static_cast <bool> (inferredReturnTypes.size() == 1u &&
 "mismatched number of return types") ? void (0) : __assert_fail
 ("inferredReturnTypes.size() == 1u && \"mismatched number of return types\""
, "tools/mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
, 9282, __extension__ __PRETTY_FUNCTION__));
  odsState.addTypes(inferredReturnTypes);
} else {
  ::llvm::report_fatal_error("Failed to infer result type(s).");
}
9287}

:mlir::LogicalResult SelectOp::verifyInvariantsImpl() {
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSOperands(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps3(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup1 = getODSOperands(1);

  for (auto v : valueGroup1) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps6(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
  auto valueGroup2 = getODSOperands(2);

  for (auto v : valueGroup2) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps6(*this, v.getType(), "operand", index++)))
      return ::mlir::failure();
  }
}
{
  unsigned index = 0; (void)index;
  auto valueGroup0 = getODSResults(0);

  for (auto v : valueGroup0) {
    if (::mlir::failed(__mlir_ods_local_type_constraint_ArithmeticOps6(*this, v.getType(), "result", index++)))
      return ::mlir::failure();
  }
}
if (!((::llvm::is_splat(::llvm::makeArrayRef({(*this->getODSOperands(1).begin()).getType(), (*this->getODSOperands(2).begin()).getType(), (*this->getODSResults(0).begin()).getType()})))))
  return emitOpError("failed to verify that all of {true_value, false_value, result} have same type");
return ::mlir::success();
9323}

:mlir::LogicalResult SelectOp::verifyInvariants() {
if(::mlir::succeeded(verifyInvariantsImpl()) && ::mlir::succeeded(verify()))
  return ::mlir::success();
return ::mlir::failure();
9329}

:mlir::LogicalResult SelectOp::inferReturnTypes(::mlir::MLIRContext *context, ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
inferredReturnTypes.resize(1);
::mlir::Builder odsBuilder(context);
inferredReturnTypes[0] = operands[2].getType();
return ::mlir::success();
9336}

9338void SelectOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects) {
9339}

9341} // namespace arith
9342} // namespace mlir
9343MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::arith::SelectOp)namespace mlir { namespace detail { SelfOwningTypeID TypeIDResolver
< ::mlir::arith::SelectOp>::id = {}; } }


9346#endif  // GET_OP_CLASSES


←

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/mlir/include/mlir/IR/Attributes.h

1//===- Attributes.h - MLIR Attribute Classes --------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8 
9#ifndef MLIR_IR_ATTRIBUTES_H
10#define MLIR_IR_ATTRIBUTES_H
11 
12#include "mlir/IR/AttributeSupport.h"
13#include "llvm/Support/PointerLikeTypeTraits.h"
14 
15namespace mlir {
16class StringAttr;
17 
18/// Attributes are known-constant values of operations.
19///
20/// Instances of the Attribute class are references to immortal key-value pairs
21/// with immutable, uniqued keys owned by MLIRContext. As such, an Attribute is
22/// a thin wrapper around an underlying storage pointer. Attributes are usually
23/// passed by value.
24class Attribute {
25public:
26  /// Utility class for implementing attributes.
27  template <typename ConcreteType, typename BaseType, typename StorageType,
28            template <typename T> class... Traits>
29  using AttrBase = detail::StorageUserBase<ConcreteType, BaseType, StorageType,
30                                           detail::AttributeUniquer, Traits...>;
31 
32  using ImplType = AttributeStorage;
33  using ValueType = void;
34  using AbstractTy = AbstractAttribute;
35 
36  constexpr Attribute() {}
37  /* implicit */ Attribute(const ImplType *impl)
38      : impl(const_cast<ImplType *>(impl)) {}
39 
40  Attribute(const Attribute &other) = default;
41  Attribute &operator=(const Attribute &other) = default;
42 
43  bool operator==(Attribute other) const { return impl == other.impl; }
44  bool operator!=(Attribute other) const { return !(*this == other); }
45  explicit operator bool() const { return impl; }
46 
47  bool operator!() const { return impl == nullptr; }
48 
49  template <typename U> bool isa() const;
50  template <typename First, typename Second, typename... Rest>
51  bool isa() const;
52  template <typename First, typename... Rest>
53  bool isa_and_nonnull() const;
54  template <typename U> U dyn_cast() const;
55  template <typename U> U dyn_cast_or_null() const;
56  template <typename U> U cast() const;
57 
58  // Support dyn_cast'ing Attribute to itself.
59  static bool classof(Attribute) { return true; }
60 
61  /// Return a unique identifier for the concrete attribute type. This is used
62  /// to support dynamic type casting.
63  TypeID getTypeID() { return impl->getAbstractAttribute().getTypeID(); }
64 
65  /// Return the type of this attribute.
66  Type getType() const { return impl->getType(); }
5
←
Called C++ object pointer is null
67 
68  /// Return the context this attribute belongs to.
69  MLIRContext *getContext() const;
70 
71  /// Get the dialect this attribute is registered to.
72  Dialect &getDialect() const {
73    return impl->getAbstractAttribute().getDialect();
74  }
75 
76  /// Print the attribute.
77  void print(raw_ostream &os) const;
78  void dump() const;
79 
80  /// Get an opaque pointer to the attribute.
81  const void *getAsOpaquePointer() const { return impl; }
82  /// Construct an attribute from the opaque pointer representation.
83  static Attribute getFromOpaquePointer(const void *ptr) {
84    return Attribute(reinterpret_cast<const ImplType *>(ptr));
85  }
86 
87  friend ::llvm::hash_code hash_value(Attribute arg);
88 
89  /// Returns true if the type was registered with a particular trait.
90  template <template <typename T> class Trait>
91  bool hasTrait() {
92    return getAbstractAttribute().hasTrait<Trait>();
93  }
94 
95  /// Return the abstract descriptor for this attribute.
96  const AbstractTy &getAbstractAttribute() const {
97    return impl->getAbstractAttribute();
98  }
99 
100protected:
101  ImplType *impl{nullptr};
102};
103 
104inline raw_ostream &operator<<(raw_ostream &os, Attribute attr) {
105  attr.print(os);
106  return os;
107}
108 
109template <typename U> bool Attribute::isa() const {
110  assert(impl && "isa<> used on a null attribute.")(static_cast <bool> (impl && "isa<> used on a null attribute."
) ? void (0) : __assert_fail ("impl && \"isa<> used on a null attribute.\""
, "mlir/include/mlir/IR/Attributes.h", 110, __extension__ __PRETTY_FUNCTION__
));
111  return U::classof(*this);
112}
113 
114template <typename First, typename Second, typename... Rest>
115bool Attribute::isa() const {
116  return isa<First>() || isa<Second, Rest...>();
117}
118 
119template <typename First, typename... Rest>
120bool Attribute::isa_and_nonnull() const {
121  return impl && isa<First, Rest...>();
122}
123 
124template <typename U> U Attribute::dyn_cast() const {
125  return isa<U>() ? U(impl) : U(nullptr);
126}
127template <typename U> U Attribute::dyn_cast_or_null() const {
128  return (impl && isa<U>()) ? U(impl) : U(nullptr);
129}
130template <typename U> U Attribute::cast() const {
131  assert(isa<U>())(static_cast <bool> (isa<U>()) ? void (0) : __assert_fail
 ("isa<U>()", "mlir/include/mlir/IR/Attributes.h", 131,
 __extension__ __PRETTY_FUNCTION__));
132  return U(impl);
133}
134 
135inline ::llvm::hash_code hash_value(Attribute arg) {
136  return DenseMapInfo<const Attribute::ImplType *>::getHashValue(arg.impl);
137}
138 
139//===----------------------------------------------------------------------===//
140// NamedAttribute
141//===----------------------------------------------------------------------===//
142 
143/// NamedAttribute represents a combination of a name and an Attribute value.
144class NamedAttribute {
145public:
146  NamedAttribute(StringAttr name, Attribute value);
147 
148  /// Return the name of the attribute.
149  StringAttr getName() const;
150 
151  /// Return the dialect of the name of this attribute, if the name is prefixed
152  /// by a dialect namespace. For example, `llvm.fast_math` would return the
153  /// LLVM dialect (if it is loaded). Returns nullptr if the dialect isn't
154  /// loaded, or if the name is not prefixed by a dialect namespace.
155  Dialect *getNameDialect() const;
156 
157  /// Return the value of the attribute.
158  Attribute getValue() const { return value; }
159 
160  /// Set the name of this attribute.
161  void setName(StringAttr newName);
162 
163  /// Set the value of this attribute.
164  void setValue(Attribute newValue) {
165    assert(value && "expected valid attribute value")(static_cast <bool> (value && "expected valid attribute value"
) ? void (0) : __assert_fail ("value && \"expected valid attribute value\""
, "mlir/include/mlir/IR/Attributes.h", 165, __extension__ __PRETTY_FUNCTION__
));
166    value = newValue;
167  }
168 
169  /// Compare this attribute to the provided attribute, ordering by name.
170  bool operator<(const NamedAttribute &rhs) const;
171  /// Compare this attribute to the provided string, ordering by name.
172  bool operator<(StringRef rhs) const;
173 
174  bool operator==(const NamedAttribute &rhs) const {
175    return name == rhs.name && value == rhs.value;
176  }
177  bool operator!=(const NamedAttribute &rhs) const { return !(*this == rhs); }
178 
179private:
180  NamedAttribute(Attribute name, Attribute value) : name(name), value(value) {}
181 
182  /// Allow access to internals to enable hashing.
183  friend ::llvm::hash_code hash_value(const NamedAttribute &arg);
184  friend DenseMapInfo<NamedAttribute>;
185 
186  /// The name of the attribute. This is represented as a StringAttr, but
187  /// type-erased to Attribute in the field.
188  Attribute name;
189  /// The value of the attribute.
190  Attribute value;
191};
192 
193inline ::llvm::hash_code hash_value(const NamedAttribute &arg) {
194  using AttrPairT = std::pair<Attribute, Attribute>;
195  return DenseMapInfo<AttrPairT>::getHashValue(AttrPairT(arg.name, arg.value));
196}
197 
198//===----------------------------------------------------------------------===//
199// AttributeTraitBase
200//===----------------------------------------------------------------------===//
201 
202namespace AttributeTrait {
203/// This class represents the base of an attribute trait.
204template <typename ConcreteType, template <typename> class TraitType>
205using TraitBase = detail::StorageUserTraitBase<ConcreteType, TraitType>;
206} // namespace AttributeTrait
207 
208//===----------------------------------------------------------------------===//
209// AttributeInterface
210//===----------------------------------------------------------------------===//
211 
212/// This class represents the base of an attribute interface. See the definition
213/// of `detail::Interface` for requirements on the `Traits` type.
214template <typename ConcreteType, typename Traits>
215class AttributeInterface
216    : public detail::Interface<ConcreteType, Attribute, Traits, Attribute,
217                               AttributeTrait::TraitBase> {
218public:
219  using Base = AttributeInterface<ConcreteType, Traits>;
220  using InterfaceBase = detail::Interface<ConcreteType, Attribute, Traits,
221                                          Attribute, AttributeTrait::TraitBase>;
222  using InterfaceBase::InterfaceBase;
223 
224private:
225  /// Returns the impl interface instance for the given type.
226  static typename InterfaceBase::Concept *getInterfaceFor(Attribute attr) {
227    return attr.getAbstractAttribute().getInterface<ConcreteType>();
228  }
229 
230  /// Allow access to 'getInterfaceFor'.
231  friend InterfaceBase;
232};
233 
234} // namespace mlir.
235 
236namespace llvm {
237 
238// Attribute hash just like pointers.
239template <> struct DenseMapInfo<mlir::Attribute> {
240  static mlir::Attribute getEmptyKey() {
241    auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
242    return mlir::Attribute(static_cast<mlir::Attribute::ImplType *>(pointer));
243  }
244  static mlir::Attribute getTombstoneKey() {
245    auto *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
246    return mlir::Attribute(static_cast<mlir::Attribute::ImplType *>(pointer));
247  }
248  static unsigned getHashValue(mlir::Attribute val) {
249    return mlir::hash_value(val);
250  }
251  static bool isEqual(mlir::Attribute LHS, mlir::Attribute RHS) {
252    return LHS == RHS;
253  }
254};
255template <typename T>
256struct DenseMapInfo<
257    T, std::enable_if_t<std::is_base_of<mlir::Attribute, T>::value>>
258    : public DenseMapInfo<mlir::Attribute> {
259  static T getEmptyKey() {
260    const void *pointer = llvm::DenseMapInfo<const void *>::getEmptyKey();
261    return T::getFromOpaquePointer(pointer);
262  }
263  static T getTombstoneKey() {
264    const void *pointer = llvm::DenseMapInfo<const void *>::getTombstoneKey();
265    return T::getFromOpaquePointer(pointer);
266  }
267};
268 
269/// Allow LLVM to steal the low bits of Attributes.
270template <> struct PointerLikeTypeTraits<mlir::Attribute> {
271  static inline void *getAsVoidPointer(mlir::Attribute attr) {
272    return const_cast<void *>(attr.getAsOpaquePointer());
273  }
274  static inline mlir::Attribute getFromVoidPointer(void *ptr) {
275    return mlir::Attribute::getFromOpaquePointer(ptr);
276  }
277  static constexpr int NumLowBitsAvailable = llvm::PointerLikeTypeTraits<
278      mlir::AttributeStorage *>::NumLowBitsAvailable;
279};
280 
281template <> struct DenseMapInfo<mlir::NamedAttribute> {
282  static mlir::NamedAttribute getEmptyKey() {
283    auto emptyAttr = llvm::DenseMapInfo<mlir::Attribute>::getEmptyKey();
284    return mlir::NamedAttribute(emptyAttr, emptyAttr);
285  }
286  static mlir::NamedAttribute getTombstoneKey() {
287    auto tombAttr = llvm::DenseMapInfo<mlir::Attribute>::getTombstoneKey();
288    return mlir::NamedAttribute(tombAttr, tombAttr);
289  }
290  static unsigned getHashValue(mlir::NamedAttribute val) {
291    return mlir::hash_value(val);
292  }
293  static bool isEqual(mlir::NamedAttribute lhs, mlir::NamedAttribute rhs) {
294    return lhs == rhs;
295  }
296};
297 
298} // namespace llvm
299 
300#endif