// `tf_device.cluster_func` ops.
// Output: A MLIR module in the Tensorflow Executor Dialect.
tensorflow::Status ExportFromTensorflowDialectToExecutor(
    mlir::ModuleOp module, llvm::StringRef module_name = llvm::StringRef());

}  // namespace v2
}  // namespace tf2xla
}  // namespace tensorflow

  }

  MarkFunctionsNoinlinePass(const MarkFunctionsNoinlinePass& other)
      : MarkFunctionsNoinlinePass() {
    noinline_functions_ = other.noinline_functions_;
  }

  StringRef getArgument() const final { return "mark-functions-noinline"; }

  StringRef getDescription() const final {
    return "Marks a function whose name is in `noinline-functions` option with "
           "the attribute `tf._noinline = true`. This attributes the function "

#include "absl/base/attributes.h"
#include "llvm/ADT/StringRef.h"
#include "mlir/Pass/PassManager.h"  // from @llvm-project

namespace tensorflow {
namespace tf2xla {
namespace internal {

// Given the pass manager, add Bridge passes to cluster the replicated input
// graphs.
void AddReplicatedBridgeClusteringPipelinePasses(
    mlir::OpPassManager& pm, llvm::StringRef module_name = llvm::StringRef());

    quantization_method_ = other.quantization_method_;
    op_set_ = other.op_set_;
  }

  StringRef getArgument() const final {
    // This is the argument used to refer to the pass in the textual format (on
    // the commandline for example).
    return "quant-insert-quantized-functions";
  }

  StringRef getDescription() const final {
    // This is a brief description of the pass.

  return accepted_dialects;
}

bool IsAcceptedDialect(llvm::StringRef dialect_name,
                       const std::vector<std::string>& accepted_dialects) {
  return std::find(accepted_dialects.begin(), accepted_dialects.end(),
                   dialect_name) != accepted_dialects.end();
}

bool IsAcceptedOp(llvm::StringRef dialect_name, llvm::StringRef op_name,
                  const std::vector<std::string>& accepted_dialects) {

#include <utility>

#include "llvm/ADT/StringExtras.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project

namespace mlir {
namespace quant {

constexpr StringRef kTfEntryFunctionAttr = "tf.entry_function";

void AddEntryFunctionInput(StringRef input_name, func::FuncOp func_op) {
  auto entry_func_attr =
      func_op->getAttrOfType<DictionaryAttr>(kTfEntryFunctionAttr);
  if (!entry_func_attr) return;

void EnablePassIRPrinting(mlir::PassManager& pm,
                          const std::string& dump_group_name,
                          llvm::StringRef module_name = llvm::StringRef());

};  // namespace internal
};  // namespace tf2xla
};  // namespace tensorflow

==============================================================================*/

#include <memory>
#include <string>

#include "absl/log/log.h"
#include "absl/status/status.h"
#include "llvm/ADT/StringRef.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/Pass/PassManager.h"  // from @llvm-project

#include "llvm/ADT/StringRef.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project

namespace mlir {
namespace quant {

// Adds a new input name to the `inputs` field of the `tf.entry_function`
// attribute if the attribute exist in the given function. Otherwise, no
// attribute is modified.
void AddEntryFunctionInput(StringRef input_name, func::FuncOp func_op);

}  // namespace quant

#include <memory>

#include "llvm/ADT/StringRef.h"
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/Pass/Pass.h"  // from @llvm-project

namespace mlir {
namespace TFTPU {

// Creates a pass that rewrites `tf_device.launch_func` on TPUs into TPU runtime
// ops.
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> CreateTPURewritePass(
    llvm::StringRef module_name = llvm::StringRef());