// Squeezed, here, means eliminating any 1s' in the
// dimensions of the tensor
def GetSqueezedShape: NativeCodeCall<"GetSqueezedShape($0)">;

// This is a utility function to deduct the effective permutation to apply on
// TFL_TransposeOp when the tensor has some dimensions with value==1
def GetSqueezedPermutation: NativeCodeCall<"GetSqueezedPermutation($0, $1)">;

// Check to see if the tensor dimensions can be Squeezed by eliminating 1s'

// Make the 1D value $0 broadcastable with the shape of $1.
def MakeOneDimValueBroadcastable : NativeCodeCall<
  "MakeOneDimValueBroadcastable($_builder, $_loc, $0, $1.getType().cast<ShapedType>())">;

// Match convolution op with "NHWC" data format or matmul op.
def SupportedAffineOpMatcher : NativeCodeCall<
  "MatchSupportedAffineOp($_self, $0, $1, $2)">;

// Checks if a value can be symetrically quantized.

def IsPrecisionEmpty :
  Constraint<CPred<"IsPrecisionEmpty($0)">>;

// Creates Einsum Op from XlaDotV2 Op by generating equation.
def CreateEinsumOpFromXlaDotV2Op : NativeCodeCall<
  "CreateEinsumOpFromXlaDotV2Op($_builder, $_loc, $0...)">;

// Convert XlaDotV2 Op to Einsum Op with above two functions.
def ConvertXlaDotV2OpToEinsumOp : Pat<

def CheckHasResourceSubtype : Constraint<CPred<"HasResourceSubtype($0)">>;

def CreateConstBoolAttrFalse : NativeCodeCall<"$_builder.getBoolAttr(false)">;

def CreateTFReadVariableOpFromResourceHandle : NativeCodeCall<
    "$_builder.create<TF::ReadVariableOp>("
    "$0.getLoc(), GetResourceSubtype($1), $1)">;

def CreateTFSelectOp: NativeCodeCall<
    "$_builder.create<TF::SelectOp>("
    "$0.getLoc(), $3.getType(), $1, $2, $3)">;

def DenseElementsAttr : ElementsAttrBase<
  CPred<"$_self.isa<DenseElementsAttr>()">,
  "non-opaque constant tensor">;

def CreateGatherNdOp : NativeCodeCall<
    "$_builder.create<TF::GatherNdOp>($0.getLoc(), $0.getType(), $1, $2)">;

def CreateTFCastOpI32 : NativeCodeCall<
    "CreateTFCastOpI32(&$_builder, $_loc, $0, $1)">;

// Convert to std constant for statically shaped, non-opaque constants.

    "new dimensions are inserted in intermediate positions">;

// Return intermediate shape before broadcasting, wrapped in a constant op.
def ExpandedShape : NativeCodeCall<"ExpandedShape($_builder, $0, $1, $2)">;
def ExpandedDynamicShape : NativeCodeCall<"ExpandedDynamicShape($_builder, $0, $1, $2)">;

def : Pat<(MHLO_ConstantOp:$output $value), (TF_ConstOp $value),
          [(TF_Tensor $output)]>;

include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.td"

def CreateXLAConvOpFromTFConv2DOp : NativeCodeCall<
  "CreateXlaConvOpFromTfConv2dOp($_builder, $_loc, $0...)">;

def CreateXLAConvOpFromTFDepthwiseConv2DOp : NativeCodeCall<
  "CreateXlaConvOpFromTfDepthwiseConv2dOp($_builder, $_loc, $0...)">;

def CreateXlaDotV2OpFromTfMatMulOp : NativeCodeCall<
  "CreateXlaDotV2OpFromTfMatMulOp($_builder, $_loc, $0...)">;

include "mlir/IR/OpBase.td"
include "mlir/IR/PatternBase.td"

// Here, the element type can be any integer or float type. But, note that only
// 32 bit integers are supported for the values.
class GetScalarOfType<int value> : NativeCodeCall<
  "GetScalarOfType(getElementTypeOrSelf($0)," # value # ")">;

// Here, the element type can be any integer or float type. But, note that only
// 32 bit integers are supported for the values.

// Gather op patterns.
//===----------------------------------------------------------------------===//

class GetI32Attr<int x>: NativeCodeCall<
  "$_builder.getI32IntegerAttr(" # x # ")">;

class GetI64Attr<int x>: NativeCodeCall<
  "$_builder.getI64IntegerAttr(" # x # ")">;

// The deprecated validate_indices attribute is NOT verified during

include "mlir/IR/OpBase.td"
include "mlir/IR/BuiltinAttributes.td"
include "mlir/IR/CommonAttrConstraints.td"
include "mlir/IR/CommonTypeConstraints.td"

def CloneF32ElementsAttrWithOnes
  : NativeCodeCall<"DenseElementsAttr::get($0.getType().cast<ShapedType>(), (float)1.0)">;

def NotConstant : Constraint<
    CPred<"$0.isa<BlockArgument>() || !llvm::isa<stablehlo::ConstantOp>($0.getDefiningOp())">,
    "Is not a constant.">;