getOperation(), max_iterations_, /*ops_to_skip=*/{}, input_shapes_);
    if (failed(failure_or_converged)) return signalPassFailure();
    if (!failure_or_converged.value()) {
      getOperation().emitError()
          << "shape inference pass did not reach convergence after "
          << max_iterations_;
      return signalPassFailure();
    }
  }

 private:
  ArrayRef<ArrayRef<int64_t>> input_shapes_;
};
}  // namespace

      module_in, confs, &graph, &flib_def, &control_ret_nodes);
  if (!status.ok()) {
    mlir::emitError(mlir::UnknownLoc::get(&ctx)) << status.message();
    return signalPassFailure();
  }

  // Run each of the passes that were selected.
  GraphConstructorOptions opts;
  opts.allow_internal_ops = true;
  opts.expect_device_spec = false;

  GraphOptimizationPassOptions options;

  DataFlowSolver solver;
  solver.load<dataflow::DeadCodeAnalysis>();
  solver.load<dataflow::SparseConstantPropagation>();
  TF::LoadResourceDataflowAnalysis(solver);
  if (failed(solver.initializeAndRun(module))) return signalPassFailure();

  DenseSet<GlobalTensorOp> remaining_global_tensor_ops;
  {
    auto ops = module.getOps<GlobalTensorOp>();
    remaining_global_tensor_ops.insert(ops.begin(), ops.end());
  }

  // ops.
  if (failed(tensorflow::VerifyExportSuitable(module_op))) {
    signalPassFailure();
    return;
  }
  TF::OpToParallelIdsMap op_to_parallel_ids_map;
  if (failed(FillOpToParallelIdsMap(module_op, op_to_parallel_ids_map))) {
    signalPassFailure();
    return;
  }
  TF::SideEffectAnalysis side_effect_analysis(module_op,

  if (entry_funcs.empty()) {
    LOG(WARNING) << "missing entry functions";
  }

  if (HasNoNestedEntryFunctions(entry_funcs, symtab).failed()) {
    return signalPassFailure();
  }

  if (HasTopLevelCompilationMarker(entry_funcs).failed()) {
    return signalPassFailure();
  }
}

}  // namespace

namespace TFDevice {
std::unique_ptr<OperationPass<ModuleOp>> CreateXlaValidateInputsPass() {

      ParseTextProto(GetQuantizationSpecsTextProto(quantization_specs_));
  if (!quantization_specs.ok()) {
    signalPassFailure();
    return;
  }

  pass_manager.addPass(
      CreateLiftQuantizableSpotsAsFunctionsPass(*quantization_specs));

  if (failed(pass_manager.run(getOperation()))) {
    signalPassFailure();
  }
}

}  // namespace

  RewritePatternSet patterns(ctx);
  mhlo::populateUnfuseBatchNormPatterns(ctx, &patterns);

  if (failed(
          applyPatternsAndFoldGreedily(getOperation(), std::move(patterns)))) {
    return signalPassFailure();
  }
}
}  // namespace

      GetFunctionLibrary(quantization_method_, op_set_);

  if (quantized_function_library.empty()) {
    emitError(module.getLoc())
        << "Failed to get function library for the opset.";
    signalPassFailure();
    return;
  }

  mem_buffer =
      llvm::MemoryBuffer::getMemBuffer(quantized_function_library,
                                       /*BufferName=*/"",

void RewriteTPUEmbeddingOps::runOnOperation() {
  func::FuncOp func = getOperation();
  if (failed(RunOnRegion(&func.getBody()))) return signalPassFailure();

  func.walk([&](Operation* op) {
    for (Region& region : op->getRegions()) {
      if (failed(RunOnRegion(&region))) return signalPassFailure();
    }
  });
}

}  // anonymous namespace

std::unique_ptr<OperationPass<func::FuncOp>>

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

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizeIntGraphPass() {
  return std::make_unique<OptimizeIntGraph>();
}