"@llvm-project//mlir:Support",
        "@llvm-project//mlir:TransformUtils",
        "@llvm-project//mlir:Transforms",
        "@local_xla//xla:status",
        "@local_xla//xla:statusor",
        "@local_xla//xla/mlir_hlo",
        "@stablehlo//:stablehlo_ops",
    ],
)

cc_library(
    name = "tensorflow_lite_optimize",
    srcs = [
        "transforms/generated_optimize.inc",
        "transforms/optimize.cc",

}

def TF_XlaRecvOp : TF_Op<"XlaRecv", [TF_RecvSideEffect]> {
  let summary = [{
Receives the named tensor from another XLA computation. Wraps the XLA Recv
  }];

  let description = [{
operator documented at
 https://www.tensorflow.org/performance/xla/operation_semantics#recv .
  }];

  let arguments = (ins
    StrAttr:$tensor_name,
    TF_ShapeAttr:$shape
  );

}

def TPUValidateInputsPass : Pass<"tf-tpu-validate-inputs", "ModuleOp"> {
  let summary = "Validates inputs to the TPU TF/XLA bridge";

  let description = [{
    This pass checks that the IR has valid input to TPU TF/XLA bridge.
    It checks the relations of multiple ops. Properties of single ops are
    checked by the 'verify' method of ops.
  }];

                ' of compute capabilities excluding version %s.' % ver)
            all_valid = False
          if ver < 35:
            print('WARNING: XLA does not support CUDA compute capabilities '
                  'lower than sm_35. Disable XLA when running on older GPUs.')
      else:
        ver = float(m.group(0))
        if ver < 3.0:

        Eager mode.

*   `tf.lite`:

    *   Enable TFLite experimental new converter by default.

*   XLA

    *   XLA now builds and works on windows. All prebuilt packages come with XLA
        available.
    *   XLA can be
        [enabled for a `tf.function`](https://www.tensorflow.org/xla#explicit_compilation_with_tffunction)
        with “compile or throw exception” semantics on CPU and GPU.

          devices.device_names(), num_replicas, num_cores_per_replica,
          topology_attr.getValue(), status_or_device_coodinates.value());
  return success();
}

// Move a broadcast into the XLA cluster, converting it to an XlaAllReduce. This
// skips if the element type is not known to be valid for XlaAllReduce.
LogicalResult MoveBroadcastToCluster(OpBuilder& builder,

#include "tensorflow/compiler/mlir/tensorflow/transforms/passes.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_saved_model_passes.h"
#include "xla/mlir_hlo/mhlo/transforms/passes.h"

namespace mlir {
/// Create a pass to convert from the TFExecutor to the TF control dialect.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateTFExecutorToControlDialectConversion();

#include "tensorflow/compiler/mlir/tensorflow/utils/translate_utils.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/verify_suitable_for_graph_export.h"
#include "tensorflow/compiler/mlir/utils/name_utils.h"
#include "xla/status_macros.h"
#include "tensorflow/core/framework/function.h"
#include "tensorflow/core/framework/graph.pb.h"
#include "tensorflow/core/framework/graph_to_functiondef.h"
#include "tensorflow/core/framework/node_def.pb.h"

        op, input.getType(), scalar_zero,
        ArrayRef<Value>({slice1, expanded_item, slice2}));
    return success();
  }

  // This function rewrites the original op into a XLA DynamicUpdateSlice op.
  // |item| is expanded to have the same dimension as input_handle and
  // |index| is expanded to [index, 0, 0, ...] as the indices to input_handle.
  // On a high level, it's doing something like:

  let summary = "DynamicUpdateSlice.";
  let description = [{
    DynamicUpdateSlice op that have the same semantics with XLA
    DynamicUpdateSlice.
    Generates a result which is the value of the input array
    operand, with a slice update overwritten at start_indices.

    See https://www.tensorflow.org/xla/operation_semantics#dynamicupdateslice.
  }];

  let arguments = (ins