AddFunctionsForExportedNamesPass> {
  void runOnOperation() override;
};

// Set the (array of) exported name(s) of a (public) function to just
// contain the given string.
void SetExportedName(func::FuncOp f, StringRef name) {
  OpBuilder b(f);
  f->removeAttr(kTfSavedModelExportedNamesAttr);
  f->setAttr(kTfSavedModelExportedNamesAttr, b.getStrArrayAttr({name}));
}

        /*is_hybrid=*/is_hybrid);

    const mlir::func::FuncOp quantized_func = dyn_cast_or_null<func::FuncOp>(
        symbol_table.lookup(quantized_function_name));
    if (quantized_func == nullptr) {
      call_op->emitError("Failed to find the quantized function: " +
                         quantized_function_name);
      return failure();
    }
    mlir::func::FuncOp new_quantized_func =

  // ranges.
  bool SetInputNodesQuantizationParams(func::FuncOp func);

  // The function might contain more stats ops than required, and it will
  // introduce requantize if the calibration stats have conflicts. This method
  // tries to remove all the redundant stats ops.
  bool RemoveRedundantStats(func::FuncOp func);

  // Verify the quantization specification is expected for quantizing the

  return failure(result.wasInterrupted());
}

void ConvertToLegacyCompileAndReplicateAttributesPass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  if (failed(ConvertToLegacyAttributes(func_op))) return signalPassFailure();
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>
CreateConvertToLegacyCompileAndReplicateAttributesPass() {
  return std::make_unique<ConvertToLegacyCompileAndReplicateAttributesPass>();

#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback_util.h"

#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback_async.h"

namespace tfrt {
namespace fallback_async {

bool IsArgConsumedByFallback(mlir::func::FuncOp func, int arg_index) {
  auto arg = func.getArgument(arg_index);

  // Return true if any user is a fallback op. It is more interesting to know
  // whether it is consumed by any fallback op than whether it is only consumed

      }
    });
  }
};
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateSimpleTFDeviceAssignmentPass(
    llvm::StringRef default_device) {
  return std::make_unique<SimpleTFDeviceAssignmentPass>(default_device);
}

std::unique_ptr<OperationPass<func::FuncOp>>
CreateTFDeviceAssignmentByFuncAttrPass() {
  return std::make_unique<TFDeviceAssignmentByFuncAttrPass>();
}

// is "restore_op". Creates and returns a new initializer function iff such
// `FuncOp` is not found. The newly created initializer function's
// initializer_type is "restore_op" and its symbol will be added to the symbol
// table and session_initializer op's "intializer" attribute.
func::FuncOp GetOrCreateInitializerFunc(ModuleOp module_op) {
  if (auto init_func_op = GetInitializerFunction(

    ModuleOp module) {
  SymbolTableCollection table;
  SymbolUserMap symbol_map(table, module);
  llvm::DenseMap<func::FuncOp, llvm::DenseSet<func::FuncOp>> caller_callee_map;
  // Creates work queue for determining reachability below.
  std::queue<func::FuncOp> function_worklist;

  for (auto func : module.getOps<func::FuncOp>()) {
    for (auto user : symbol_map.getUsers(func)) {

            argument_index = i;
            break;
          }
        }

        // Copy the const into the consumer func and replace their usages.
        func::FuncOp func = module.lookupSymbol<func::FuncOp>(function_name);

        CopyConstantIntoFunc(argument_index, op, func);
      }
    });
  }
}

}  // namespace

  LogicalResult ModifyInputNodes(func::FuncOp func,
                                 llvm::SmallVectorImpl<Type>& new_input_types,
                                 OpBuilder builder);

  // Modifies the element types of entry block returns to be user specified
  // and returns the new return types.
  LogicalResult ModifyOutputNodes(func::FuncOp func,