chore: import upstream snapshot with attribution

tensorflow/compiler/mlir/lite/delegates/BUILD

@@ -0,0 +1,27 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = ["//visibility:public"],
+    licenses = ["notice"],
+)
+
+# LINT.IfChange(config_setting)
+config_setting(
+    name = "tflite_debug_delegate",
+    define_values = {"tflite_debug_delegate": "true"},
+)
+# LINT.ThenChange(//tensorflow/lite/delegates/BUILD)

tensorflow/compiler/mlir/lite/delegates/flex/BUILD

@@ -0,0 +1,45 @@
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load(
+    "//tensorflow:tensorflow.bzl",
+    "if_mobile",
+    "if_not_mobile",
+)
+load("//tensorflow:tensorflow.default.bzl", "get_compatible_with_portable")
+load("//tensorflow/lite:special_rules.bzl", "internal_visibility_allowlist")
+
+default_visibility = [
+    "//tensorflow/compiler/mlir/lite:__subpackages__",
+    "//tensorflow/lite/android:__subpackages__",
+    "//tensorflow/lite/toco/tflite:__subpackages__",
+]
+
+#
+# This is a TF Lite delegate that is powered by TensorFlow's Eager.
+#
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = default_visibility,
+    licenses = ["notice"],
+)
+
+cc_library(
+    name = "allowlisted_flex_ops_lib",
+    srcs = [
+        "allowlisted_flex_ops.cc",
+    ],
+    hdrs = [
+        "allowlisted_flex_ops.h",
+        "allowlisted_flex_ops_internal.h",
+    ],
+    compatible_with = get_compatible_with_portable(),
+    copts = select({
+        "//tensorflow:android": ["-Wno-private-header"],
+        "//conditions:default": [],
+    }),
+    visibility = internal_visibility_allowlist(),
+    deps = if_mobile([
+        "//tensorflow/core:portable_tensorflow_lib_lite",
+    ]) + if_not_mobile([
+        "//tensorflow/core:framework",
+    ]),
+)

tensorflow/compiler/mlir/lite/delegates/flex/allowlisted_flex_ops.cc

@@ -0,0 +1,852 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#include "tensorflow/compiler/mlir/lite/delegates/flex/allowlisted_flex_ops.h"
+
+#include <set>
+#include <string>
+
+#include "tensorflow/compiler/mlir/lite/delegates/flex/allowlisted_flex_ops_internal.h"
+#include "tensorflow/core/framework/op.h"
+
+namespace tflite {
+namespace flex {
+
+const std::set<std::string>& GetFlexAllowlist() {
+  // LINT.IfChange
+  static const std::set<std::string>* allowlisted_flex_ops =
+      new std::set<std::string>({
+          // go/keep-sorted start
+          "Abort",
+          "Abs",
+          "Add",
+          "AddN",
+          "AddV2",
+          "AdjustContrast",
+          "AdjustContrastv2",
+          "AdjustHue",
+          "AdjustSaturation",
+          "All",
+          "Angle",
+          "Any",
+          "ApplyAdaMax",
+          "ApplyAdadelta",
+          "ApplyAdagrad",
+          "ApplyAdagradDA",
+          "ApplyAdagradV2",
+          "ApplyAdam",
+          "ApplyAddSign",
+          "ApplyCenteredRMSProp",
+          "ApplyFtrl",
+          "ApplyFtrlV2",
+          "ApplyGradientDescent",
+          "ApplyMomentum",
+          "ApplyPowerSign",
+          "ApplyProximalAdagrad",
+          "ApplyProximalGradientDescent",
+          "ApplyRMSProp",
+          "ApproximateEqual",
+          "ArgMax",
+          "ArgMin",
+          "AsString",
+          "Assert",
+          "Assign",
+          "AssignAdd",
+          "AssignAddVariableOp",
+          "AssignSub",
+          "AssignSubVariableOp",
+          "AssignVariableOp",
+          "Atan",
+          "Atan2",
+          "AudioSpectrogram",
+          "AvgPool",
+          "AvgPool3D",
+          "AvgPool3DGrad",
+          "AvgPoolGrad",
+          "BatchCholesky",
+          "BatchDatasetV2",
+          "BatchMatMul",
+          "BatchMatMulV2",
+          "BatchMatrixBandPart",
+          "BatchMatrixDeterminant",
+          "BatchMatrixDiag",
+          "BatchMatrixDiagPart",
+          "BatchMatrixInverse",
+          "BatchMatrixSetDiag",
+          "BatchMatrixTriangularSolve",
+          "BatchNormWithGlobalNormalization",
+          "BatchNormWithGlobalNormalizationGrad",
+          "BatchToSpace",
+          "BatchToSpaceND",
+          "BiasAdd",
+          "BiasAddGrad",
+          "BiasAddV1",
+          "Bincount",
+          "Bitcast",
+          "BitwiseAnd",
+          "BitwiseOr",
+          "BitwiseXor",
+          "BroadcastArgs",
+          "BroadcastGradientArgs",
+          "BroadcastTo",
+          "Bucketize",
+          "CTCBeamSearchDecoder",
+          "CTCGreedyDecoder",
+          "Case",
+          "Cast",
+          "Ceil",
+          "CheckNumerics",
+          "CheckNumericsV2",
+          "Cholesky",
+          "ClipByValue",
+          "CombinedNonMaxSuppression",
+          "Complex",
+          "ComplexAbs",
+          "Concat",
+          "ConcatOffset",
+          "ConcatV2",
+          "Conj",
+          "ConjugateTranspose",
+          "Const",
+          "ControlTrigger",
+          "Conv2D",
+          "Conv2DBackpropFilter",
+          "Conv2DBackpropInput",
+          "Conv3D",
+          "Conv3DBackpropFilter",
+          "Conv3DBackpropFilterV2",
+          "Conv3DBackpropInput",
+          "Conv3DBackpropInputV2",
+          "Cos",
+          "Cosh",
+          "CropAndResize",
+          "CropAndResizeGradBoxes",
+          "CropAndResizeGradImage",
+          "Cumprod",
+          "Cumsum",
+          "CumulativeLogsumexp",
+          "DataFormatDimMap",
+          "DataFormatVecPermute",
+          "DebugGradientIdentity",
+          "DebugGradientRefIdentity",
+          "DecodeAndCropJpeg",
+          "DecodeBase64",
+          "DecodeBmp",
+          "DecodeGif",
+          "DecodeImage",
+          "DecodeJpeg",
+          "DecodePaddedRaw",
+          "DecodePng",
+          "DecodeRaw",
+          "DecodeWav",
+          "DeepCopy",
+          "DeleteSessionTensor",
+          "DenseBincount",
+          "DenseToDenseSetOperation",
+          "DenseToSparseSetOperation",
+          "DepthToSpace",
+          "DepthwiseConv2dNative",
+          "DepthwiseConv2dNativeBackpropFilter",
+          "DepthwiseConv2dNativeBackpropInput",
+          "Dequantize",
+          "DestroyResourceOp",
+          "DestroyTemporaryVariable",
+          "Diag",
+          "DiagPart",
+          "Dilation2D",
+          "Dilation2DBackpropFilter",
+          "Dilation2DBackpropInput",
+          "Div",
+          "DivNoNan",
+          "DynamicPartition",
+          "DynamicStitch",
+          "Einsum",
+          "Elu",
+          "EluGrad",
+          "Empty",
+          "EmptyTensorList",
+          "EmptyTensorMap",
+          "EncodeBase64",
+          "EncodeJpeg",
+          "EncodeJpegVariableQuality",
+          "EncodePng",
+          "EncodeWav",
+          "EnsureShape",
+          "Enter",
+          "Equal",
+          "Erf",
+          "Exit",
+          "Exp",
+          "ExpandDims",
+          "ExtractImagePatches",
+          "FFT",
+          "FFT2D",
+          "FFT3D",
+          "FIFOQueue",
+          "FIFOQueueV2",
+          "FakeQuantWithMinMaxArgs",
+          "FakeQuantWithMinMaxArgsGradient",
+          "FakeQuantWithMinMaxVars",
+          "FakeQuantWithMinMaxVarsGradient",
+          "FakeQuantWithMinMaxVarsPerChannel",
+          "FakeQuantWithMinMaxVarsPerChannelGradient",
+          "FakeQueue",
+          "Fill",
+          "FilterDataset",
+          "FinalizeDataset",
+          "Fingerprint",
+          "FlatMapDataset",
+          "Floor",
+          "FloorDiv",
+          "FloorMod",
+          "FusedBatchNorm",
+          "FusedBatchNormGrad",
+          "FusedBatchNormGradV2",
+          "FusedBatchNormGradV3",
+          "FusedBatchNormV2",
+          "FusedBatchNormV3",
+          "FusedPadConv2D",
+          "FusedResizeAndPadConv2D",
+          "Gather",
+          "GatherNd",
+          "GatherV2",
+          "GetSessionHandle",
+          "GetSessionHandleV2",
+          "GetSessionTensor",
+          "Greater",
+          "GreaterEqual",
+          "HSVToRGB",
+          "HashTable",
+          "HashTableV2",
+          "HistogramSummary",
+          "IFFT",
+          "IFFT2D",
+          "IFFT3D",
+          "IRFFT",
+          "IRFFT2D",
+          "IRFFT3D",
+          "Identity",
+          "IdentityN",
+          "Imag",
+          "ImageProjectiveTransformV2",
+          "ImageProjectiveTransformV3",
+          "ImmutableConst",
+          "InTopK",
+          "InTopKV2",
+          "InitializeTable",
+          "InitializeTableFromDataset",
+          "InitializeTableFromTextFile",
+          "InitializeTableFromTextFileV2",
+          "InitializeTableV2",
+          "InplaceAdd",
+          "InplaceSub",
+          "InplaceUpdate",
+          "Inv",
+          "InvGrad",
+          "Invert",
+          "InvertPermutation",
+          "IsFinite",
+          "IsNan",
+          "IsVariableInitialized",
+          "LRN",
+          "LeakyRelu",
+          "LeakyReluGrad",
+          "LeftShift",
+          "Less",
+          "LessEqual",
+          "LinSpace",
+          "ListDiff",
+          "Log",
+          "LogMatrixDeterminant",
+          "LogSoftmax",
+          "LogicalAnd",
+          "LogicalNot",
+          "LogicalOr",
+          "LookupTableExport",
+          "LookupTableExportV2",
+          "LookupTableFind",
+          "LookupTableFindV2",
+          "LookupTableImport",
+          "LookupTableImportV2",
+          "LookupTableInsert",
+          "LookupTableInsertV2",
+          "LookupTableRemoveV2",
+          "LookupTableSize",
+          "LookupTableSizeV2",
+          "LoopCond",
+          "MapDataset",
+          "MatMul",
+          "MatrixBandPart",
+          "MatrixDeterminant",
+          "MatrixDiag",
+          "MatrixDiagPart",
+          "MatrixDiagPartV2",
+          "MatrixDiagPartV3",
+          "MatrixDiagV2",
+          "MatrixDiagV3",
+          "MatrixInverse",
+          "MatrixSetDiag",
+          "MatrixSetDiagV2",
+          "MatrixSetDiagV3",
+          "MatrixTriangularSolve",
+          "Max",
+          "MaxPool",
+          "MaxPool3D",
+          "MaxPool3DGrad",
+          "MaxPool3DGradGrad",
+          "MaxPoolGrad",
+          "MaxPoolGradGrad",
+          "MaxPoolGradGradV2",
+          "MaxPoolGradV2",
+          "MaxPoolGradWithArgmax",
+          "MaxPoolV2",
+          "MaxPoolWithArgmax",
+          "Maximum",
+          "Mean",
+          "Merge",
+          "MergeSummary",
+          "MergeV2Checkpoints",
+          "Mfcc",
+          "Min",
+          "Minimum",
+          "MirrorPad",
+          "MirrorPadGrad",
+          "ModelDataset",
+          "Mul",
+          "MulNoNan",
+          "Multinomial",
+          "MutableDenseHashTable",
+          "MutableDenseHashTableV2",
+          "MutableHashTable",
+          "MutableHashTableOfTensors",
+          "MutableHashTableOfTensorsV2",
+          "MutableHashTableV2",
+          "Neg",
+          "NextIteration",
+          "NoOp",
+          "NonMaxSuppression",
+          "NonMaxSuppressionV2",
+          "NonMaxSuppressionV3",
+          "NonMaxSuppressionV4",
+          "NonMaxSuppressionV5",
+          "NonMaxSuppressionWithOverlaps",
+          "NotEqual",
+          "OneHot",
+          "OnesLike",
+          "OptimizeDatasetV2",
+          "OptionalFromValue",
+          "OptionalGetValue",
+          "OptionalHasValue",
+          "OptionalNone",
+          "Pack",
+          "Pad",
+          "PadV2",
+          "PaddingFIFOQueue",
+          "PaddingFIFOQueueV2",
+          "ParallelConcat",
+          "ParallelDynamicStitch",
+          "ParseExample",
+          "ParseExampleV2",
+          "ParseSequenceExample",
+          "ParseSequenceExampleV2",
+          "ParseSingleExample",
+          "ParseSingleSequenceExample",
+          "Placeholder",
+          "PlaceholderV2",
+          "PlaceholderWithDefault",
+          "PopulationCount",
+          "Pow",
+          "PreventGradient",
+          "Print",
+          "PrintV2",
+          "Prod",
+          "Qr",
+          "QuantizeDownAndShrinkRange",
+          "QuantizeV2",
+          "QuantizedAdd",
+          "QuantizedAvgPool",
+          "QuantizedBatchNormWithGlobalNormalization",
+          "QuantizedBiasAdd",
+          "QuantizedConcat",
+          "QuantizedConv2D",
+          "QuantizedInstanceNorm",
+          "QuantizedMatMul",
+          "QuantizedMaxPool",
+          "QuantizedMul",
+          "QuantizedRelu",
+          "QuantizedRelu6",
+          "QuantizedReshape",
+          "QuantizedResizeBilinear",
+          "QueueClose",
+          "QueueCloseV2",
+          "QueueDequeue",
+          "QueueDequeueMany",
+          "QueueDequeueManyV2",
+          "QueueDequeueUpTo",
+          "QueueDequeueUpToV2",
+          "QueueDequeueV2",
+          "QueueEnqueue",
+          "QueueEnqueueMany",
+          "QueueEnqueueManyV2",
+          "QueueEnqueueV2",
+          "QueueIsClosed",
+          "QueueIsClosedV2",
+          "QueueSize",
+          "QueueSizeV2",
+          "RFFT",
+          "RFFT2D",
+          "RFFT3D",
+          "RGBToHSV",
+          "RaggedBincount",
+          "RaggedGather",
+          "RaggedRange",
+          "RaggedTensorFromVariant",
+          "RaggedTensorToSparse",
+          "RaggedTensorToTensor",
+          "RaggedTensorToVariant",
+          "RaggedTensorToVariantGradient",
+          "RandomGamma",
+          "RandomPoisson",
+          "RandomPoissonV2",
+          "RandomShuffle",
+          "RandomStandardNormal",
+          "RandomUniform",
+          "RandomUniformInt",
+          "Range",
+          "Rank",
+          "ReadFile",
+          "ReadVariableOp",
+          "Real",
+          "RealDiv",
+          "Reciprocal",
+          "ReciprocalGrad",
+          "Recv",
+          "ReduceDataset",
+          "ReduceJoin",
+          "RefEnter",
+          "RefExit",
+          "RefIdentity",
+          "RefMerge",
+          "RefNextIteration",
+          "RefSelect",
+          "RefSwitch",
+          "RegexFullMatch",
+          "RegexReplace",
+          "Relu",
+          "Relu6",
+          "Relu6Grad",
+          "ReluGrad",
+          "RemoteCall",
+          "RepeatDataset",
+          "RequantizationRange",
+          "Requantize",
+          "Reshape",
+          "ResizeBicubic",
+          "ResizeBicubicGrad",
+          "ResizeBilinear",
+          "ResizeBilinearGrad",
+          "ResizeNearestNeighbor",
+          "ResizeNearestNeighborGrad",
+          "ResourceApplyAdaMax",
+          "ResourceApplyAdadelta",
+          "ResourceApplyAdagrad",
+          "ResourceApplyAdagradDA",
+          "ResourceApplyAdagradV2",
+          "ResourceApplyAdam",
+          "ResourceApplyAdamWithAmsgrad",
+          "ResourceApplyAddSign",
+          "ResourceApplyCenteredRMSProp",
+          "ResourceApplyFtrl",
+          "ResourceApplyFtrlV2",
+          "ResourceApplyGradientDescent",
+          "ResourceApplyKerasMomentum",
+          "ResourceApplyMomentum",
+          "ResourceApplyPowerSign",
+          "ResourceApplyProximalAdagrad",
+          "ResourceApplyProximalGradientDescent",
+          "ResourceApplyRMSProp",
+          "ResourceGather",
+          "ResourceGatherNd",
+          "ResourceScatterAdd",
+          "ResourceScatterDiv",
+          "ResourceScatterMax",
+          "ResourceScatterMin",
+          "ResourceScatterMul",
+          "ResourceScatterNdAdd",
+          "ResourceScatterNdMax",
+          "ResourceScatterNdMin",
+          "ResourceScatterNdSub",
+          "ResourceScatterNdUpdate",
+          "ResourceScatterSub",
+          "ResourceScatterUpdate",
+          "ResourceSparseApplyAdadelta",
+          "ResourceSparseApplyAdagrad",
+          "ResourceSparseApplyAdagradDA",
+          "ResourceSparseApplyAdagradV2",
+          "ResourceSparseApplyCenteredRMSProp",
+          "ResourceSparseApplyFtrl",
+          "ResourceSparseApplyFtrlV2",
+          "ResourceSparseApplyKerasMomentum",
+          "ResourceSparseApplyMomentum",
+          "ResourceSparseApplyProximalAdagrad",
+          "ResourceSparseApplyProximalGradientDescent",
+          "ResourceSparseApplyRMSProp",
+          "ResourceStridedSliceAssign",
+          "Restore",
+          "RestoreSlice",
+          "RestoreV2",
+          "Reverse",
+          "ReverseSequence",
+          "ReverseV2",
+          "RightShift",
+          "Roll",
+          "Round",
+          "Rsqrt",
+          "RsqrtGrad",
+          "SampleDistortedBoundingBox",
+          "SampleDistortedBoundingBoxV2",
+          "Save",
+          "SaveSlices",
+          "SaveV2",
+          "ScalarSummary",
+          "ScatterNd",
+          "ScatterNdAdd",
+          "ScatterNdMax",
+          "ScatterNdMin",
+          "ScatterNdNonAliasingAdd",
+          "ScatterNdSub",
+          "ScatterNdUpdate",
+          "SegmentMax",
+          "SegmentMean",
+          "SegmentMin",
+          "SegmentProd",
+          "SegmentSum",
+          "Select",
+          "SelectV2",
+          "Selu",
+          "SeluGrad",
+          "Send",
+          "SerializeTensor",
+          "Shape",
+          "ShapeN",
+          "ShardedFilename",
+          "ShardedFilespec",
+          "Sigmoid",
+          "SigmoidGrad",
+          "Sign",
+          "Sin",
+          "Sinh",
+          "Size",
+          "Slice",
+          "Softmax",
+          "SoftmaxCrossEntropyWithLogits",
+          "Softplus",
+          "SoftplusGrad",
+          "Softsign",
+          "SoftsignGrad",
+          "SpaceToBatch",
+          "SpaceToBatchND",
+          "SpaceToDepth",
+          "SparseAdd",
+          "SparseApplyAdadelta",
+          "SparseApplyAdagrad",
+          "SparseApplyAdagradDA",
+          "SparseApplyAdagradV2",
+          "SparseApplyCenteredRMSProp",
+          "SparseApplyFtrl",
+          "SparseApplyFtrlV2",
+          "SparseApplyMomentum",
+          "SparseApplyProximalAdagrad",
+          "SparseApplyProximalGradientDescent",
+          "SparseApplyRMSProp",
+          "SparseBincount",
+          "SparseCross",
+          "SparseCrossHashed",
+          "SparseCrossV2",
+          "SparseFillEmptyRows",
+          "SparseFillEmptyRowsGrad",
+          "SparseReduceSum",
+          "SparseReorder",
+          "SparseReshape",
+          "SparseSegmentMean",
+          "SparseSegmentMeanGrad",
+          "SparseSegmentMeanWithNumSegments",
+          "SparseSegmentSqrtN",
+          "SparseSegmentSqrtNGrad",
+          "SparseSegmentSqrtNWithNumSegments",
+          "SparseSegmentSum",
+          "SparseSegmentSumGrad",
+          "SparseSegmentSumWithNumSegments",
+          "SparseSlice",
+          "SparseSoftmaxCrossEntropyWithLogits",
+          "SparseTensorDenseMatMul",
+          "SparseToDense",
+          "SparseToSparseSetOperation",
+          "Split",
+          "SplitV",
+          "Sqrt",
+          "SqrtGrad",
+          "Square",
+          "SquaredDifference",
+          "Squeeze",
+          "Stack",
+          "StackClose",
+          "StackCloseV2",
+          "StackPop",
+          "StackPopV2",
+          "StackPush",
+          "StackPushV2",
+          "StackV2",
+          "StatelessMultinomial",
+          "StatelessRandomGammaV2",
+          "StatelessRandomGammaV3",
+          "StatelessRandomGetAlg",
+          "StatelessRandomGetKeyCounter",
+          "StatelessRandomGetKeyCounterAlg",
+          "StatelessRandomNormal",
+          "StatelessRandomNormalV2",
+          "StatelessRandomPoisson",
+          "StatelessRandomUniform",
+          "StatelessRandomUniformFullInt",
+          "StatelessRandomUniformFullIntV2",
+          "StatelessRandomUniformInt",
+          "StatelessRandomUniformIntV2",
+          "StatelessRandomUniformV2",
+          "StatelessSampleDistortedBoundingBox",
+          "StatelessTruncatedNormal",
+          "StatelessTruncatedNormalV2",
+          "StaticRegexFullMatch",
+          "StaticRegexReplace",
+          "StopGradient",
+          "StridedSlice",
+          "StridedSliceAssign",
+          "StridedSliceGrad",
+          "StringFormat",
+          "StringJoin",
+          "StringLength",
+          "StringLower",
+          "StringSplit",
+          "StringSplitV2",
+          "StringStrip",
+          "StringToHashBucket",
+          "StringToHashBucketFast",
+          "StringToHashBucketStrong",
+          "StringToNumber",
+          "Sub",
+          "Substr",
+          "Sum",
+          "Switch",
+          "SymbolicGradient",
+          "TakeDataset",
+          "TakeWhileDataset",
+          "Tan",
+          "Tanh",
+          "TanhGrad",
+          "TemporaryVariable",
+          "TensorArray",
+          "TensorArrayClose",
+          "TensorArrayCloseV2",
+          "TensorArrayCloseV3",
+          "TensorArrayConcat",
+          "TensorArrayConcatV2",
+          "TensorArrayConcatV3",
+          "TensorArrayGather",
+          "TensorArrayGatherV2",
+          "TensorArrayGatherV3",
+          "TensorArrayGrad",
+          "TensorArrayGradV2",
+          "TensorArrayGradV3",
+          "TensorArrayGradWithShape",
+          "TensorArrayPack",
+          "TensorArrayRead",
+          "TensorArrayReadV2",
+          "TensorArrayReadV3",
+          "TensorArrayScatter",
+          "TensorArrayScatterV2",
+          "TensorArrayScatterV3",
+          "TensorArraySize",
+          "TensorArraySizeV2",
+          "TensorArraySizeV3",
+          "TensorArraySplit",
+          "TensorArraySplitV2",
+          "TensorArraySplitV3",
+          "TensorArrayUnpack",
+          "TensorArrayV2",
+          "TensorArrayV3",
+          "TensorArrayWrite",
+          "TensorArrayWriteV2",
+          "TensorArrayWriteV3",
+          "TensorListConcat",
+          "TensorListConcatLists",
+          "TensorListConcatV2",
+          "TensorListElementShape",
+          "TensorListFromTensor",
+          "TensorListGather",
+          "TensorListGetItem",
+          "TensorListLength",
+          "TensorListPopBack",
+          "TensorListPushBack",
+          "TensorListPushBackBatch",
+          "TensorListReserve",
+          "TensorListResize",
+          "TensorListScatter",
+          "TensorListScatterIntoExistingList",
+          "TensorListScatterV2",
+          "TensorListSetItem",
+          "TensorListSplit",
+          "TensorListStack",
+          "TensorMapErase",
+          "TensorMapHasKey",
+          "TensorMapInsert",
+          "TensorMapLookup",
+          "TensorMapSize",
+          "TensorMapStackKeys",
+          "TensorScatterAdd",
+          "TensorScatterMax",
+          "TensorScatterMin",
+          "TensorScatterSub",
+          "TensorScatterUpdate",
+          "TensorSliceDataset",
+          "TensorStridedSliceUpdate",
+          "Tile",
+          "TileGrad",
+          "Timestamp",
+          "TopK",
+          "TopKV2",
+          "Transpose",
+          "TruncateDiv",
+          "TruncatedNormal",
+          "UnicodeDecode",
+          "UnicodeDecodeWithOffsets",
+          "UnicodeEncode",
+          "UnicodeTranscode",
+          "Unique",
+          "UniqueV2",
+          "UniqueWithCounts",
+          "UniqueWithCountsV2",
+          "Unpack",
+          "UnsortedSegmentJoin",
+          "UnsortedSegmentMax",
+          "UnsortedSegmentMin",
+          "UnsortedSegmentProd",
+          "UnsortedSegmentSum",
+          "UnwrapDatasetVariant",
+          "UpperBound",
+          "VarHandleOp",
+          "VarIsInitializedOp",
+          "Variable",
+          "VariableShape",
+          "VariableV2",
+          "Where",
+          "WrapDatasetVariant",
+          "WriteFile",
+          "Xdivy",
+          "Xlog1py",
+          "Xlogy",
+          "ZerosLike",
+          "_Arg",
+          "_ArrayToList",
+          "_DeviceArg",
+          "_DeviceRetval",
+          "_FusedConv2D",
+          "_HostCast",
+          "_HostRecv",
+          "_HostSend",
+          "_ListToArray",
+          "_ParallelConcatStart",
+          "_ParallelConcatUpdate",
+          "_ReadVariablesOp",
+          "_Recv",
+          "_Retval",
+          "_Send",
+          "_SwitchN",
+          "_VarHandlesOp",
+          // go/keep-sorted end
+      });
+  // LINT.ThenChange(//tensorflow/lite/g3doc/guide/op_select_allowlist.md)
+
+  return *allowlisted_flex_ops;
+  // Prevent lint error about this function being too long. This function
+  // is a set of ops, and making it shorter won't help readbility.
+  // NOLINTNEXTLINE
+}
+
+const std::set<std::string>& GetTFTextFlexAllowlist() {
+  // LINT.IfChange
+  static const std::set<std::string>* tftext_flex_ops =
+      new std::set<std::string>({
+          "CaseFoldUTF8",
+          "ConstrainedSequence",
+          "MaxSpanningTree",
+          "NormalizeUTF8",
+          "NormalizeUTF8WithOffsetsMap",
+          "RegexSplitWithOffsets",
+          "RougeL",
+          "SentenceFragments",
+          "SentencepieceOp",
+          "SentencepieceTokenizeOp",
+          "SentencepieceTokenizeWithOffsetsOp",
+          "SentencepieceDetokenizeOp",
+          "SentencepieceVocabSizeOp",
+          "SplitMergeTokenizeWithOffsets",
+          "TFText>NgramsStringJoin",
+          "TFText>WhitespaceTokenizeWithOffsetsV2",
+          "TokenizerFromLogits",
+          "UnicodeScriptTokenizeWithOffsets",
+          "WhitespaceTokenizeWithOffsets",
+          "WordpieceTokenizeWithOffsets",
+      });
+  // LINT.ThenChange(//tensorflow/lite/g3doc/guide/op_select_allowlist.md)
+
+  return *tftext_flex_ops;
+}
+
+// Allow the tf.text ops if they are registered in the global op registry.
+bool IsAllowedTFTextOpForFlex(const std::string& op_name) {
+  if (GetTFTextFlexAllowlist().count(op_name) == 0) return false;
+  return tensorflow::OpRegistry::Global()->LookUp(op_name) != nullptr;
+}
+
+const std::set<std::string>& GetSentencePieceFlexAllowlist() {
+  // LINT.IfChange
+  static const std::set<std::string>* sentencepiece_flex_ops =
+      new std::set<std::string>({
+          "SentencepieceGetPieceSize",
+          "SentencepiecePieceToId",
+          "SentencepieceIdToPiece",
+          "SentencepieceEncodeDense",
+          "SentencepieceEncodeSparse",
+          "SentencepieceDecode",
+      });
+  // LINT.ThenChange(//tensorflow/lite/g3doc/guide/op_select_allowlist.md)
+
+  return *sentencepiece_flex_ops;
+}
+
+// Allow the sentencepiece ops if they are registered in the global op registry.
+bool IsAllowedSentencePieceOpForFlex(const std::string& op_name) {
+  if (GetSentencePieceFlexAllowlist().count(op_name) == 0) return false;
+  return tensorflow::OpRegistry::Global()->LookUp(op_name) != nullptr;
+}
+
+bool IsAllowlistedFlexOp(const std::string& tensorflow_op_name) {
+  if (GetFlexAllowlist().count(tensorflow_op_name) != 0) return true;
+
+  // Check if the op is an allowlisted tf.text or sentencepiece op.
+  return IsAllowedTFTextOpForFlex(tensorflow_op_name) ||
+         IsAllowedSentencePieceOpForFlex(tensorflow_op_name);
+}
+
+}  // namespace flex
+}  // namespace tflite

tensorflow/compiler/mlir/lite/delegates/flex/allowlisted_flex_ops.h

@@ -0,0 +1,45 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_COMPILER_MLIR_LITE_DELEGATES_FLEX_ALLOWLISTED_FLEX_OPS_H_
+#define TENSORFLOW_COMPILER_MLIR_LITE_DELEGATES_FLEX_ALLOWLISTED_FLEX_OPS_H_
+
+#include <set>
+#include <string>
+
+namespace tflite {
+namespace flex {
+
+// Whether the given op has been statically allowlisted for flex export.
+//
+// This static allowlist is formed by the intersection of ops supported by
+// TensorFlowMobile on both iOS and Android. As the converter is likely running
+// on a host that has the full suite of TensorFlow ops available, we use this
+// static allowlist to ensure compatibility when deploying to a mobile device.
+// TODO(b/118389105): Automate generation of the allowlisted flex ops.
+bool IsAllowlistedFlexOp(const std::string& tensorflow_op_name);
+
+// Return the list of allowlisted flex ops.
+const std::set<std::string>& GetFlexAllowlist();
+
+// Return the list of TF.Text flex ops.
+const std::set<std::string>& GetTFTextFlexAllowlist();
+
+// Return the list of SentencePiece flex ops.
+const std::set<std::string>& GetSentencePieceFlexAllowlist();
+
+}  // namespace flex
+}  // namespace tflite
+
+#endif  // TENSORFLOW_COMPILER_MLIR_LITE_DELEGATES_FLEX_ALLOWLISTED_FLEX_OPS_H_

tensorflow/compiler/mlir/lite/delegates/flex/allowlisted_flex_ops_internal.h

@@ -0,0 +1,29 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_COMPILER_MLIR_LITE_DELEGATES_FLEX_ALLOWLISTED_FLEX_OPS_INTERNAL_H_
+#define TENSORFLOW_COMPILER_MLIR_LITE_DELEGATES_FLEX_ALLOWLISTED_FLEX_OPS_INTERNAL_H_
+
+#include <string>
+
+namespace tflite {
+namespace flex {
+
+// Return true if op_name is a tf.text op need to be supported by flex delegate.
+bool IsAllowedTFTextOpForFlex(const std::string& op_name);
+
+}  // namespace flex
+}  // namespace tflite
+
+#endif  // TENSORFLOW_COMPILER_MLIR_LITE_DELEGATES_FLEX_ALLOWLISTED_FLEX_OPS_INTERNAL_H_

tensorflow/compiler/mlir/lite/delegates/flex/build_def.bzl

@@ -0,0 +1,190 @@
+"""Generate custom flex delegate library."""
+
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load(
+    "//tensorflow:tensorflow.bzl",
+    "clean_dep",
+    "if_android",
+    "if_ios",
+    "if_mobile",
+    "tf_cc_binary",
+    "tf_copts",
+    "tf_defines_nortti_if_lite_protos",
+    "tf_features_nomodules_if_mobile",
+    "tf_opts_nortti_if_lite_protos",
+    "tf_portable_full_lite_protos",
+)
+load("//tensorflow/compiler/mlir/lite:special_rules.bzl", "flex_portable_tensorflow_deps")
+
+# LINT.IfChange
+
+def generate_flex_kernel_header(
+        name,
+        models,
+        testonly = 0,
+        additional_deps = []):
+    """A rule to generate a header file listing only used operators.
+
+    Args:
+      name: Name of the generated library.
+      models: TFLite models to interpret.
+      testonly: Should be marked as true if additional_deps is testonly.
+      additional_deps: Dependencies for additional TF ops.
+
+    Returns:
+      A struct with 'header' and 'include_path' fields that
+      contain the generated header and the required include entry.
+    """
+    include_path = "%s_tf_generated_kernel_header" % name
+    header = include_path + "/ops_to_register.h"
+
+    if type(models) != type([]):
+        models = [models]
+
+    # List all flex ops from models.
+    model_file_args = " --graphs=%s" % ",".join(
+        ["$(location %s)" % f for f in models],
+    )
+    list_ops_output = include_path + "/list_flex_ops"
+    list_ops_tool = clean_dep("//tensorflow/lite/tools:list_flex_ops_main")
+    if additional_deps:
+        tf_cc_binary(
+            name = "%s_list_flex_ops_main" % name,
+            deps = [
+                clean_dep("//tensorflow/lite/tools:list_flex_ops_main_lib"),
+            ] + additional_deps,
+            testonly = testonly,
+        )
+        list_ops_tool = ":%s_list_flex_ops_main" % name
+    native.genrule(
+        name = "%s_list_flex_ops" % name,
+        srcs = models,
+        outs = [list_ops_output],
+        tools = [list_ops_tool],
+        message = "Listing flex ops from %s..." % ",".join(models),
+        cmd = ("$(location " + list_ops_tool + ")" +
+               model_file_args + " > \"$@\""),
+        testonly = testonly,
+    )
+
+    # Generate the kernel registration header file from list of flex ops.
+    tool = clean_dep("//tensorflow/python/tools:print_selective_registration_header")
+    native.genrule(
+        name = "%s_kernel_registration" % name,
+        srcs = [list_ops_output],
+        outs = [header],
+        tools = [tool],
+        message = "Processing %s..." % list_ops_output,
+        cmd = ("$(location " + tool + ")" +
+               " --default_ops=\"\"" +
+               " --proto_fileformat=ops_list" +
+               " --graphs=" + "$(location " + list_ops_output + ") > \"$@\""),
+    )
+    return struct(include_path = include_path, header = header)
+
+def tflite_flex_cc_library(
+        name,
+        models = [],
+        additional_deps = [],
+        testonly = 0,
+        visibility = ["//visibility:public"],
+        link_symbol = True,
+        compatible_with = None):
+    """A rule to generate a flex delegate with only ops to run listed models.
+
+    Args:
+      name: Name of the generated flex delegate.
+      models: TFLite models to interpret. The library will only include ops and kernels
+          to support these models. If empty, the library will include all Tensorflow
+          ops and kernels.
+      additional_deps: Dependencies for additional TF ops.
+      testonly: Mark this library as testonly if true.
+      visibility: visibility of the generated rules.
+      link_symbol: If true, add delegate_symbol to deps.
+      compatible_with: The standard compatible_with attribute.
+    """
+    portable_tensorflow_lib = clean_dep("//tensorflow/core:portable_tensorflow_lib")
+    if models:
+        CUSTOM_KERNEL_HEADER = generate_flex_kernel_header(
+            name = "%s_tf_op_headers" % name,
+            models = models,
+            additional_deps = additional_deps,
+            testonly = testonly,
+        )
+
+        # Define a custom tensorflow_lib with selective registration.
+        # The library will only contain ops exist in provided models.
+        cc_library(
+            name = "%s_tensorflow_lib" % name,
+            srcs = if_mobile([
+                clean_dep("//tensorflow/core:portable_op_registrations_and_gradients"),
+                clean_dep("//tensorflow/core/kernels:portable_core_ops"),
+                clean_dep("//tensorflow/core/kernels:portable_extended_ops"),
+            ]) + [CUSTOM_KERNEL_HEADER.header],
+            copts = tf_copts(android_optimization_level_override = None) + tf_opts_nortti_if_lite_protos() + if_ios(["-Os"]),
+            compatible_with = compatible_with,
+            defines = [
+                "SELECTIVE_REGISTRATION",
+                "SUPPORT_SELECTIVE_REGISTRATION",
+                "EIGEN_NEON_GEBP_NR=4",
+            ] + tf_portable_full_lite_protos(
+                full = [],
+                lite = ["TENSORFLOW_LITE_PROTOS"],
+            ) + tf_defines_nortti_if_lite_protos(),
+            features = tf_features_nomodules_if_mobile(),
+            linkopts = if_android(["-lz"]) + if_ios(["-lz"]),
+            includes = [
+                CUSTOM_KERNEL_HEADER.include_path,
+            ],
+            textual_hdrs = [
+                clean_dep("//tensorflow/core/kernels:portable_all_ops_textual_hdrs"),
+            ],
+            visibility = visibility,
+            deps = flex_portable_tensorflow_deps() + [
+                clean_dep("@ducc//:fft_wrapper"),
+                clean_dep("//tensorflow/core:protos_all_cc"),
+                clean_dep("//tensorflow/core:portable_tensorflow_lib_lite"),
+                clean_dep("//tensorflow/core/platform:strong_hash"),
+                clean_dep("//tensorflow/lite/delegates/flex:portable_images_lib"),
+            ],
+            alwayslink = 1,
+            testonly = testonly,
+        )
+        portable_tensorflow_lib = ":%s_tensorflow_lib" % name
+
+    delegate_symbol = []
+    if link_symbol:
+        delegate_symbol.append(clean_dep("//tensorflow/lite/delegates/flex:delegate_symbol"))
+
+    # Define a custom flex delegate with above tensorflow_lib.
+    cc_library(
+        name = name,
+        hdrs = [
+            clean_dep("//tensorflow/lite/delegates/flex:delegate.h"),
+        ],
+        compatible_with = compatible_with,
+        visibility = visibility,
+        deps = [
+            clean_dep("//tensorflow/lite/delegates/flex:delegate_data"),
+            clean_dep("//tensorflow/lite/delegates/flex:delegate_only_runtime"),
+            clean_dep("//tensorflow/lite/delegates/utils:simple_delegate"),
+        ] + select({
+            clean_dep("//tensorflow:android"): [
+                portable_tensorflow_lib,
+            ],
+            clean_dep("//tensorflow:ios"): [
+                portable_tensorflow_lib,
+            ],
+            clean_dep("//tensorflow:chromiumos"): [
+                portable_tensorflow_lib,
+            ],
+            "//conditions:default": [
+                clean_dep("//tensorflow/core:tensorflow"),
+                clean_dep("//tensorflow/lite/core/c:private_common"),
+            ],
+        }) + additional_deps + delegate_symbol,
+        testonly = testonly,
+        alwayslink = 1,
+    )
+
+# LINT.ThenChange(//tensorflow/lite/delegates/flex/build_def.bzl)