hdrs = ["gradients/grad_helper.h"],
    visibility = ["//tensorflow:internal"],
    deps = [
        ":cc_ops",
        "//tensorflow/cc:ops",
        "//tensorflow/cc:scope",
    ],
)

cc_library(
    name = "linalg_grad",
    srcs = ["gradients/linalg_grad.cc"],
    deps = [
        ":cc_ops",
        ":cc_ops_internal",
        ":grad_helper",
        ":grad_op_registry",
        ":gradients",

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

#include <algorithm>
#include <cstdint>
#include <functional>
#include <limits>
#include <numeric>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>

  llvm::SmallVector<TF::IfRegionOp, 8> sub_merged_groups;
  auto begin_if_op_iter = if_ops.begin();

  while (begin_if_op_iter != if_ops.end()) {
    auto current_last_if_op_iter =
        FindLastIfInSegment(begin_if_op_iter, if_ops, side_effect_analysis);
    assert(current_last_if_op_iter != if_ops.end());
    llvm::SmallVector<TF::IfRegionOp, 8> sub_if_group;

  // it's a constant. Basically, `paddings` tensor in `SpaceToBatch` and `crops`
  // tensor  in `BatchToSpace` must satisfy the following:
  //  paddings[i, 0] = base_paddings[i, 0].
  //  0 <= paddings[i, 1] - base_paddings[i, 1] < block_shape[i]
  // (input_shape[i] + paddings[i, 0] + paddings[i, 1]) % block_shape[i] == 0.
  //  crops[i, 0] = 0.
  //  crops[i, 1] = paddings[i, 1] - base_paddings[i, 1].

        return true;
      }

      // Check if the preceding op is a quantized same-scale op.
      if (llvm::isa<quantfork::StorageCastOp>(preceding_op)) {
        auto sc_op = llvm::cast<quantfork::StorageCastOp>(preceding_op);
        auto sc_arg_type = sc_op.getArg().getType().dyn_cast<TensorType>();
        if (sc_arg_type.getElementType().isInteger(8)) {
          return true;
        }
      }
    }

    TFL::FullyConnectedOp fc_op, PatternRewriter& rewriter) const {
  // We have to know the shape of the input.
  auto input = fc_op.getInput();
  auto input_type = mlir::dyn_cast_or_null<RankedTensorType>(input.getType());
  if (!input_type || !input_type.hasStaticShape()) return failure();

  // We have to know the shape of the weight.
  auto weight = fc_op.getFilter();

  "ArrayRef<APInt>{$0.getValue(), $0.getValue()})">;

def BatchToSpaceToBatchToSpaceND : Pat<
  (TF_BatchToSpaceOp:$src $input, $crops, $block_size),
  (TF_BatchToSpaceNDOp:$dest $input,
    (TF_ConstOp (BatchToSpaceBlockSizeToBlockShape $block_size)), $crops),
  [(IsRank4Tensor $input), (IsRank2Tensor $crops)], [(CopyAttrs $src, $dest)]>;

//===----------------------------------------------------------------------===//

    const Tensor& cc_b, Tensor* cc_out,
    void (*binary_add_func)(TF_OpKernelContext* ctx, TF_Tensor* a, TF_Tensor* b,
                            TF_Tensor* out)) {
  if (cc_a.dtype() == ::tensorflow::DT_INVALID) {
    *cc_out = cc_b;
    return absl::OkStatus();
  }
  if (cc_b.dtype() == ::tensorflow::DT_INVALID) {
    *cc_out = cc_a;
    return absl::OkStatus();
  }

  Status status;

      // $orig_input_shape
      CompileTimeConstantOperand<TF::AvgPoolGradOp, 0>,
      // $block_shape, $crops
      CompileTimeConstantOperand<TF::BatchToSpaceNDOp, 1, 2>,
      CompileTimeConstantOperand<TF::BatchToSpaceOp, 1>,      // $crops
      CompileTimeConstantOperand<TF::BincountOp, 1>,          // $size
      CompileTimeConstantOperand<TF::BroadcastArgsOp, 0, 1>,  // $s0, $s1

)

exports_files([
    "ir/tf_generated_ops.td",
    "ir/tf_op_base.td",
    "ir/tf_op_interfaces.td",
    "ir/tf_ops.td",
])

td_library(
    name = "tensorflow_ops_td_files",
    srcs = [
        "ir/tf_generated_ops.td",
        "ir/tf_op_base.td",
        "ir/tf_op_interfaces.td",
        "ir/tf_ops.td",
    ],
    compatible_with = get_compatible_with_portable(),
    deps = [