if (shared_name.empty()) return false;

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module_op)) {
    for (Operation& op : init_func_op.getBody().getOps()) {
      StringRef other_shared_name = GetSharedName(&op);
      if (IsHashTableOp(&op) && other_shared_name == shared_name) {
        return true;
      }
    }
  }
  return false;
}

  const FunctionNameMatcher matcher(spec.matcher().function_name());
  // Iterate over all XlaCallModuleOp in all FuncOps.
  for (auto func : module_op.getOps<func::FuncOp>()) {
    for (auto xla_call_module_op : func.getOps<TF::XlaCallModuleOp>()) {
      if (!matcher.Match(xla_call_module_op)) continue;

      // Set the text representation of `Method` to matched
      // `TF::XlaCallModuleOp`.

void InsertCallOnceOpFromSessionInitializerPass::runOnOperation() {
  ModuleOp module = getOperation();

  for (func::FuncOp init_func_op :
       tf_saved_model::GetInitializerFunctions(module)) {
    for (auto func : module.getOps<func::FuncOp>()) {
      auto dict_attr =
          func->getAttrOfType<mlir::DictionaryAttr>("tf.entry_function");
      if (!dict_attr) continue;

      OpBuilder builder(func.getContext());

  mlir::Builder builder(context);
  StringAttr resource_name_id = builder.getStringAttr(kResourceNameArgAttr);

  SmallSet<StringRef, 4> resource_names;

  for (func::FuncOp func : module.getOps<func::FuncOp>()) {
    for (int i = 0, e = func.getNumArguments(); i < e; ++i) {
      auto resource_arg =
          func.getArgAttrOfType<StringAttr>(i, kResourceNameArgAttr);
      if (!resource_arg) continue;

    if (!main_func) continue;

    SymbolTable symbol_table(module_op);
    for (auto call_op : main_func.getOps<TF::PartitionedCallOp>()) {
      func_ops.push_back(dyn_cast_or_null<func::FuncOp>(symbol_table.lookup(
          mlir::cast<FlatSymbolRefAttr>(call_op.getFAttr()).getValue())));
    }
    for (auto call_op : main_func.getOps<TF::StatefulPartitionedCallOp>()) {
      func_ops.push_back(

  bool need_prefix_for_output_name = false;
  std::vector<StringRef> fn_input_name_vec, fn_output_name_vec;
  StringSet<> input_name_set, output_name_set;
  for (auto func_op : module_op.getOps<func::FuncOp>()) {
    if (!ShouldIncludeInMainFunction(func_op)) continue;
    if (auto tf_attrs =
            func_op->getAttrOfType<DictionaryAttr>(kEntryFunctionAttr)) {

template <typename GemmStyleOp>
// Match for all gemm_style op and check for possible fusions.
LogicalResult MatchGemmStyleOp(func::FuncOp entry_func_op) {
  const auto op_iterator_range = entry_func_op.getOps<GemmStyleOp>();
  if (op_iterator_range.empty()) {
    LLVM_DEBUG(llvm::dbgs() << "Function does not have "
                            << GemmStyleOp::getOperationName() << " op.\n");
    return failure();
  }

		host, port, err := net.SplitHostPort(addr)
		if err != nil {
			return nil, err
		}

		if net.ParseIP(host) != nil {
			// For IP only setups there is no need for DNS lookups.
			return baseDialCtx(ctx, "tcp", addr)
		}

		ips, err := lookupHost(ctx, host)
		if err != nil {
			return nil, err
		}

		for _, ip := range ips {

  void runOnOperation() override {
    ModuleOp op = this->getOperation();
    DerivedT& derived = *static_cast<DerivedT*>(this);
    auto& analysis = this->template getAnalysis<AnalysisT>();

    for (auto func : op.getOps<func::FuncOp>())
      if (!func.isExternal())
        derived.runOnFunction(func, analysis.GetAnalysisForFunc(func));
  }
};

}  // namespace TF
}  // namespace mlir

## Outside of Kubernetes

The annotation above configures a volume mount and configures Istio to use it.
When running outside of Kubernetes or in custom setups, similar functionality can be achieved by setting the `ISTIO_BOOTSTRAP_OVERRIDE` variable pointing to a file containing the custom bootstrap.

## Cleanup

```bash
kubectl delete -f custom-bootstrap.yaml