// moved to the main function. Returns failure() iff validation fails.
FailureOr<absl::flat_hash_map<std::string, func::FuncOp>> GetInitFuncOps(
    ModuleOp module_op) {
  absl::flat_hash_map<std::string, func::FuncOp> init_func_ops;

  for (func::FuncOp init_func_op : GetInitializerFunctions(module_op)) {
    if (failed(ValidateInitFunc(init_func_op))) {
      return failure();
    }

};

// Returns true iff func_op has either no Region or the body has no Blocks.
bool IsFuncOpEmpty(func::FuncOp func_op) {
  return func_op->getNumRegions() == 0 || func_op.getBody().empty();
}

// Gets the GraphOp from the function op. Returns an empty op iff it doesn't
// exist.
GraphOp GetGraphOpFromFuncOp(func::FuncOp func_op) {
  if (IsFuncOpEmpty(func_op)) return {};

  auto graph_op_range = func_op.front().without_terminator();

void EliminateUnusedResultsForIfCase(Operation *op,
                                     ArrayRef<func::FuncOp> branches) {
  // Clone branch functions if needed since we will be mutating them.
  SmallVector<func::FuncOp, 2> cloned_branches;
  cloned_branches.reserve(branches.size());
  for (func::FuncOp func : branches) {
    func::FuncOp cloned = CloneFunctionIfNeeded(func);
    cloned_branches.push_back(cloned);

// A subgraph may associate with 1...n FuncOp, and each FuncOp may correspond
// with different hardwares.
struct Subgraph {
  // The call can be thought as an "API".
  func::CallOp call;

  // available_choces can be viewed as "real implementation" assosicated with
  // the hardware.
  std::unordered_map<InferenceDeviceType, func::FuncOp,
                     InferenceDeviceType::inference_device_type_hash>

def QuantizeWeightPass : Pass<"stablehlo-quantize-weight", "mlir::func::FuncOp"> {
  let summary = "Quantizes the weight component of StableHLO graph.";
  let dependentDialects = ["mlir::stablehlo::StablehloDialect"];
  let constructor = "mlir::quant::stablehlo::CreateQuantizeWeightPass()";
}

def UnfuseMhloBatchNormPass : Pass<"stablehlo-unfuse-mhlo-batch-norm", "mlir::func::FuncOp"> {
  let summary = "Unfuses batch normalization into arithmetic ops.";

  }

  return init_func_ops;
}

func::FuncOp GetInitializerFunction(ModuleOp module_op,
                                    const StringRef initializer_type) {
  SmallVector<func::FuncOp, 2> init_func_ops =
      GetInitializerFunctions(module_op);

  auto init_func_itr = absl::c_find_if(
      init_func_ops, [initializer_type](const func::FuncOp init_func_op) {

                             StringRef(content.data(), content.size()));
}

inline TensorType GetInputType(func::FuncOp func, int idx) {
  return mlir::dyn_cast_or_null<TensorType>(
      func.getFunctionType().getInput(idx));
}

inline TensorType GetResultType(func::FuncOp func, int idx) {
  return mlir::dyn_cast_or_null<TensorType>(
      func.getFunctionType().getResult(idx));
}

  ASSERT_TRUE(result);
  EXPECT_EQ(noinline_pcall_ops.size(), 2);
  auto func =
      llvm::dyn_cast<mlir::func::FuncOp>(noinline_pcall_ops[0]->getParentOp());
  ASSERT_TRUE(func);
  EXPECT_EQ(func.getSymName(), "while_body_func");
  func =
      llvm::dyn_cast<mlir::func::FuncOp>(noinline_pcall_ops[1]->getParentOp());
  ASSERT_TRUE(func);
  EXPECT_EQ(func.getSymName(), "outer_stateful_pcall_func");

)mlir";

TEST_F(IsOpQuantizableStableHloTest, ConstantOpQuantizable) {
  OwningOpRef<ModuleOp> module_op = ParseModuleOpString(kModuleConstantAdd);
  ASSERT_TRUE(module_op);

  auto test_func = module_op->lookupSymbol<func::FuncOp>("constant_add");
  ASSERT_THAT(test_func, NotNull());

  auto constant_op =
      FindOperationOfType<mlir::stablehlo::ConstantOp>(test_func);
  EXPECT_TRUE(IsOpQuantizableStableHlo(constant_op));
}

  void ConvertTFImplements(func::FuncOp func, StringAttr attr);
  void ConvertTFImplementsWithAttributes(func::FuncOp func, FuncAttr attr);
  void ConvertTFAPIImplements(func::FuncOp func, StringAttr attr,
                              ModuleOp module);
  void runOnOperation() override;
};

LogicalResult CheckFusableLayerNormalizedLstmCellSimple(
    func::FuncOp lstm_func) {
  for (int i = 0; i < 5; ++i) {