}

  func.func @non_const_inputs(%arg0: tensor<2x2xf64>, %arg1: tensor<f64>, %arg2: tensor<2xi32>, %arg3: tensor<2xi32>, %arg4: tensor<2xi32>) -> tensor<6x5xf64> {
    // expected-remark@+1 {{compilation to HLO failed: INVALID_ARGUMENT: Input 2 to node `tf.XlaPad` with op XlaPad must be a compile-time constant.}}

        custom_legalization_passes);

// Compiles a Graph from TF to HLO and adds the resulting HLO to the
// XlaBuilder. This function adds HLO to a larger HLO computation, so
// HLO-level inputs are supplied, and HLO-level outputs are produced.
// xla_params is the HLO-level inputs and returns is the HLO-level outputs.
// If unconditionally_use_output_shapes is true then the unregistered

// NOLINTNEXTLINE
opt<bool> import_hlo("import-hlo",
                     llvm::cl::desc("Whether the input file is hlo file."),
                     llvm::cl::init(false));

// NOLINTNEXTLINE
opt<HloImportType> hlo_import_type(
    "hlo-import-type", llvm::cl::desc("The file type of the hlo."),
    llvm::cl::values(clEnumVal(proto, "Import hlo in proto binary format"),

// Declare passes used in xla_legalize_tf.

include "mlir/Pass/PassBase.td"

def LegalizeTF : Pass<"xla-legalize-tf", "ModuleOp"> {
  let summary = "Legalize from TF dialect's or HLO dialect's control flow.";

  let description = [{
    Legalizes from TF dialect to HLO dialect. When allow_partial_conversion is
    false, emits an error if there is any operation that can't be legalized.

                                            RewritePatternSet* patterns);

/// Converts the provided Operation as well as all nested operations into HLO
/// dialect using the conversion patterns registered by the HLO dialect. When
/// allow_partial_conversion is false, emits an error if there is any operation
/// that can't be legalized.
/// When `tf2xla_fallback_device_type` is not `None`, also uses legalization

extern llvm::cl::opt<std::string> saved_model_exported_names;

// Import HLO.
enum HloImportType { proto, hlotxt, mlir_text };

extern llvm::cl::opt<bool> import_hlo;
extern llvm::cl::opt<HloImportType> hlo_import_type;

// enable_hlo_to_tf_conversion and disable_hlo_to_tfl_conversion are used to
// control the HLO to TF and HLO to TFLite conversion while debugging an

namespace tensorflow {

template <typename ExecutableType, typename ClientType>
class DeviceCompilerClient {
 public:
  DeviceCompilerClient() = default;
  virtual ~DeviceCompilerClient() = default;

  // Compiles `result` (HLO) to an `ExecutableType` using `ClientType` and
  // returns it.
  virtual StatusOr<std::unique_ptr<ExecutableType>> BuildExecutable(
      const XlaCompiler::Options& options,

                                OpBuilder* builder) {
  return builder->create<ConstantOp>(loc, hlo::getScalarOfType(ty, raw_value));
}

ConstantOp GetScalarNegZeroOfType(Type ty, Location loc, OpBuilder* builder) {
  return builder->create<ConstantOp>(loc, hlo::getScalarNegZeroOfType(ty));
}

DenseIntElementsAttr GetI64ElementsAttr(ArrayAttr attr) {
  RankedTensorType ty =

  XlaSerializedCacheKey key = 1;

  // The computation (HLO) that compilation was done for. It is correlated to
  // the input TF graph so we can use it to fingerprint the compiled binary. We
  // serialize this rather than the input graphdef because it provides a
  // stronger guarantee over what bindings are needed between the HLO and
  // calling TF graph.
  xla.HloModuleProto hlo_module = 2;

}

tensorflow::XlaCompilationResult CreateXlaComputationResult(
    const char* hlo_name) {
  auto result = tensorflow::XlaCompilationResult();
  xla::HloModuleProto hlo;
  hlo.set_name(hlo_name);
  result.computation = std::make_shared<xla::XlaComputation>(hlo);
  return result;
}

TEST(TestUtil, ComputationContainsOk) {
  constexpr char arbitrary_hlo[] = "arbitrary_hlo";
  auto result = CreateXlaComputationResult(arbitrary_hlo);