if (failed(applyPatternsAndFoldGreedily(getOperation(),
                                            std::move(patterns)))) {
      getOperation().emitError() << kBadDecompositionMessage;
      signalPassFailure();
    }
  }
};

#define GEN_PASS_DEF_DECOMPOSERESOURCEOPSINCLUSTERPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_device_passes.h.inc"

struct DecomposeResourceOpsInClusterPass

    }
    variable_v2s_to_replace.push_back(variable_v2_op);
    return mlir::WalkResult::advance();
  };

  WalkResult walk_res = func.walk(read_only_vars_fn);
  if (walk_res.wasInterrupted()) return signalPassFailure();

  for (VariableV2Op variable_v2_op : variable_v2s_to_replace) {
    builder.setInsertionPoint(variable_v2_op);
    ShapedType shaped_type =
        mlir::cast<ShapedType>(variable_v2_op.getResult().getType());

    return signalPassFailure();
  }

  auto result = getOperation().walk([&tf_dialect](tf_device::LaunchOp launch) {
    if (failed(HoistOpsAndAnnotateWithDevice(tf_dialect, launch)))
      return WalkResult::interrupt();

    return WalkResult::advance();
  });

  if (result.wasInterrupted()) return signalPassFailure();

  if (!legacy_graph_export_) {

  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }
}
}  // namespace

void RuntimeVerifyPass::runOnOperation() {
  getOperation().walk([&](TflRuntimeVerifyOpInterface op) {
    if (failed(op.VerifyTflRuntimeConstraints(
            op.getOperation(), /*emit_error_on_verify_fail=*/true)))
      signalPassFailure();
  });
}
}  // namespace

// Verifies TFL runtime constraints.
std::unique_ptr<OperationPass<func::FuncOp>> CreateRuntimeVerifyPass() {
  return std::make_unique<RuntimeVerifyPass>();
}

    patterns.add<ConvertTFConstOpToArithConstOp>(ctx);
    patterns.add<ConvertStablehloConstToArithConstOp>(ctx);
    if (failed(applyPatternsAndFoldGreedily(func_op, std::move(patterns)))) {
      signalPassFailure();
    }

    // Finally, the quantization parameters can be propagated to the rest of the
    // values (tensors).
    ApplyQuantizationParamsPropagation(
        func_op, /*is_signed=*/true, bit_width_,

    signalPassFailure();
  }

  RewritePatternSet patterns_2(&getContext());
  patterns_2
      .add<QuantizeConstPattern, ConvertQuantizeCastToUniformQuantizePattern,
           ConvertDequantizeCastToUniformDequantizePattern>(ctx);
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns_2)))) {
    signalPassFailure();
  }
}

}  // namespace

    RewritePatternSet patterns(&getContext());
    populateWithGenerated(patterns);
    PopulateFolderPatterns(patterns);
    if (failed(applyPatternsAndFoldGreedily(module, std::move(patterns)))) {
      signalPassFailure();
    }
  }
};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateSHLOSimplifyPass() {
  return std::make_unique<SHLOSimplifyPass>();
}

}  // namespace odml

          op->removeAttr(kDeviceAttr);
        }
      }
      return WalkResult::advance();
    };

    if (failed(TFTPU::WalkReachableFromTpuCluster(getOperation(), traverse_op)))
      return signalPassFailure();
  }
};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateTPUClusterCleanupAttributesPass() {
  return std::make_unique<TPUCleanupClusterAttributesPass>();
}

      op->emitWarning() << op->getName().getStringRef() << " op is temporarily "
                        << "accepted, but it should be removed in the end.";
    } else {
      // The other ops are not accepted.
      return signalPassFailure();
    }
  });
}

}  // namespace odml
}  // namespace mlir

std::unique_ptr<mlir::Pass> mlir::odml::createCheckAcceptedOpsPass(
    const std::vector<std::string> &optional_accepted_dialects) {