bool passthru_extra_args, int num_loop_carried,
                               const llvm::SetVector<Value>& extern_values,
                               const SmallVectorImpl<Type>& types,
                               Location loc) {
  MLIRContext* context = loc.getContext();
  OpBuilder builder(context);
  FunctionType type;
  if (passthru_extra_args) {

SmallVector<func::FuncOp, 4> CollectReachableFunctions(Region& region) {
  llvm::SmallPtrSet<func::FuncOp, 4> reachable_funcs;

  auto collect_reachable_funcs =
      [&reachable_funcs](Region& src,
                         SmallVectorImpl<func::FuncOp>& funcs_to_visit) {
        src.walk([&reachable_funcs, &funcs_to_visit](CallOpInterface call_op) {
          auto func = dyn_cast_or_null<func::FuncOp>(call_op.resolveCallable());

    llvm::interleaveComma(op_attr_array, p, print_key_value);
    p << '}';
  }
}

void GetExecuteOpAttrsCommon(
    mlir::MLIRContext *context, llvm::ArrayRef<mlir::Attribute> op_attr_array,
    llvm::SmallVectorImpl<std::pair<llvm::StringRef, mlir::Attribute>>
        *op_attrs);

struct ParseExecuteOpOptions {
  bool has_chain = false;
  bool has_key = false;
  bool has_device = false;
  bool has_func_attr = false;

mlir::LogicalResult GetOutputTypesForLogicalDeviceComputation(
    const int core_id, llvm::ArrayRef<xla::OpSharding> output_sharding_config,
    mlir::tf_device::ClusterFuncOp cluster_func,
    llvm::SmallVectorImpl<mlir::Type>* output_types,
    llvm::SmallVectorImpl<int>* cluster_to_core_index) {
  output_types->reserve(cluster_func.getNumResults());

  int core_index = 0;
  for (const auto& result_and_index :

          (results_size <= kSizeFactor * operands_size));
}

LogicalResult ConstantFoldFallbackHook(
    Operation* inst, ArrayRef<Attribute> operands,
    SmallVectorImpl<OpFoldResult>& results) {  // NOLINT
  if (!CanBeFolded(inst)) return failure();

  // Determine if we should attempt to fold this operation by considering the
  // size/size increase due to folding.

  VLOG(2) << s.message();
  return false;
}

mlir::LogicalResult EvaluateOperation(
    mlir::Operation* inst, llvm::ArrayRef<mlir::ElementsAttr> operands,
    TFE_Context* context, llvm::SmallVectorImpl<mlir::Attribute>* results) {
  if (!context) {
    VLOG(1) << "Can't evaluate with null context.";
    return mlir::failure();
  }
  // If any operand is nullptr returns true for a failure.

#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace tfrt {
namespace fallback_common {

void GetExecuteOpAttrsCommon(
    mlir::MLIRContext *context, llvm::ArrayRef<mlir::Attribute> op_attr_array,
    llvm::SmallVectorImpl<std::pair<llvm::StringRef, mlir::Attribute>>
        *op_attrs) {
  assert(op_attrs);
  op_attrs->clear();

  mlir::Builder builder(context);
  for (auto iter : op_attr_array) {

struct TFConstantFoldInterface : public DialectFoldInterface {
  TFConstantFoldInterface(Dialect *dialect) : DialectFoldInterface(dialect) {}
  LogicalResult fold(Operation *op, ArrayRef<Attribute> operands,
                     SmallVectorImpl<OpFoldResult> &results) const final {
    return TensorFlowDialect::constantFold(op, operands, results);
  }
};

// Helper function that implements the multi-device inlining policy behavior

      MLIRContext* context, std::optional<Location> location,         \
      ValueShapeRange operands, DictionaryAttr attributes,            \
      OpaqueProperties properties, RegionRange regions,               \
      SmallVectorImpl<ShapedTypeComponents>& inferredReturnShapes) {  \
    return inferReturnTypeComponentsFromOperands(                     \
        context, location, operands, attributes, properties, regions, \

ParseResult ParseReplicateOpOperands(
    OpAsmParser* parser, OperationState* state,
    llvm::SmallVectorImpl<llvm::SmallVector<OpAsmParser::UnresolvedOperand, 8>>*
        replicated_inputs,
    llvm::SmallVectorImpl<OpAsmParser::UnresolvedOperand>* packed_inputs,
    llvm::SmallVectorImpl<OpAsmParser::UnresolvedOperand>* region_args,
    llvm::SmallVectorImpl<Type>* region_arg_types) {
  // No operands or empty operand list.