registry.insert<mlir::tf_saved_model::TensorFlowSavedModelDialect,
                    ml_program::MLProgramDialect>();
  }

  void runOnOperation() override {
    if (failed(convertTFGlobals(getOperation()))) {
      signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> CreateLowerGlobalsToMlProgramPass() {
  return std::make_unique<LowerGlobalsToMlProgram>();
}

    }
  }
  return success();
}

void LiftQuantizableSpotsAsFunctionsPass::runOnOperation() {
  MLIRContext* ctx = &getContext();
  RewritePatternSet patterns(ctx);
  ModuleOp module_op = getOperation();

  simple_patterns::populateWithGenerated(patterns);
  fusion_patterns::populateWithGenerated(patterns);
  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

      if (dequantize_op.use_empty()) {
        dequantize_op.erase();
      }
    }
  }
  return success();
}

void ModifyIONodesPass::runOnOperation() {
  auto func = getOperation();
  auto attrs = func->getAttrOfType<mlir::DictionaryAttr>("tf.entry_function");

  // Handle the entry functions only.
  if (func.getName() != "main" && (!attrs || attrs.empty())) {
    return;
  }

 private:
  // This will be used recursively.
  const std::function<bool(Operation *)> op_has_side_effects_;
};

void PinOpsWithSideEffectsPass::runOnOperation() {
  auto fn = getOperation();
  // We're assuming (and checking) that there are no tfl::ControlNodeOps present
  // before this pass. We could relax this requirement by defining folding logic
  // for them.
  if (fn.walk([&](TFL::ControlNodeOp) {

class XlaCallModuleSerializationPass
    : public impl::XlaCallModuleSerializationPassBase<
          XlaCallModuleSerializationPass> {
 public:
  void runOnOperation() override {
    mlir::ModuleOp module = getOperation();
    mlir::SymbolTableCollection symbol_table;

    mlir::WalkResult result =
        module.walk([&](mlir::TF::XlaCallModuleOp xla_call_module) {
          if (failed(SerializeXlaCallModule(symbol_table, module,

	return t.obj
}

func (t *testAttributes) GetOldObject() runtime.Object {
	return t.oldObj
}

func (t *testAttributes) GetName() string {
	return t.name
}

func (t *testAttributes) GetOperation() admission.Operation {
	return t.operation
}

func (t *testAttributes) GetUserInfo() user.Info {
	return &user.DefaultInfo{Name: "ignored"}

  builder.create<func::ReturnOp>(
      NameLoc::get(builder.getStringAttr(kTfQuantSaveReturnOpName)));
}

void InsertSaveOpPass::runOnOperation() {
  ModuleOp module_op = getOperation();

  func::FuncOp session_init_func = GetInitializerFunction(
      module_op, /*initializer_type=*/kTfSavedModelInitializerRestoreType);
  if (!session_init_func) {

  }
};

// TODO: b/264218457 - Refactors the current file to parse preset quantization
// options and allow modular control of quantization specs.
void QuantizeWeightPass::runOnOperation() {
  func::FuncOp func = getOperation();
  MLIRContext* ctx = func.getContext();
  RewritePatternSet patterns(ctx);

  patterns.add<QuantizeWeight>(ctx, quantization_component_spec_);

  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

              << key;
          break;
        }
      }
    }
    return attrs;
  }
};

void TflToStablehloPass::runOnOperation() {
  func::FuncOp fn = getOperation();
  OpBuilder builder(fn.getContext());
  fn.walk([&](TFL::CustomOp custom_op) {
    builder.setInsertionPoint(custom_op);
    const uint8_t* option_buf = reinterpret_cast<const uint8_t*>(

              << " outside compilation regions.";
  }
}

void MarkOpsForOutsideCompilation::runOnOperation() {
  auto module = getOperation();
  const Dialect* tf_dialect = getContext().getLoadedDialect("tf");
  if (!tf_dialect) {
    getOperation().emitError() << "'tf' dialect is not registered";
    return signalPassFailure();
  }
  RewritePatternSet patterns(&getContext());