IVGCVSW-7635 Remove deprecated code due to be removed in 23.08 (ILayerSupport)

 * ILayerSupport interface - removed unstable virtual functions.
 * User instead uses IsLayerSupported accepting LayerType enum argument.
 * Backend developers should implement the ILayerSupport::IsLayerSupported
   method accepting LayerType as a switch statement with case being
   LayerType and each case calling their implementation of IsXXXSupported()

Signed-off-by: Francis Murtagh <francis.murtagh@arm.com>
Change-Id: Iaaead8320bb1b2f1bdab6b5be2e1e69d0eb482d5

13 files changed, 206 insertions, 3257 deletions

diff --git a/include/armnn/LayerSupport.hpp b/include/armnn/LayerSupport.hpp
deleted file mode 100644
index 03b706fafd..0000000000
--- a/include/armnn/LayerSupport.hpp
+++ /dev/null
@@ -1,402 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-#pragma once
-
-#include <armnn/Deprecated.hpp>
-#include <armnn/DescriptorsFwd.hpp>
-#include <armnn/Optional.hpp>
-#include <armnn/Tensor.hpp>
-#include <armnn/Types.hpp>
-#include "LstmParams.hpp"
-#include "QuantizedLstmParams.hpp"
-
-namespace armnn
-{
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsActivationSupported(const BackendId& backend,
-                           const TensorInfo& input,
-                           const TensorInfo& output,
-                           const ActivationDescriptor& descriptor,
-                           char* reasonIfUnsupported = nullptr,
-                           size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsAdditionSupported(const BackendId& backend,
-                         const TensorInfo& input0,
-                         const TensorInfo& input1,
-                         const TensorInfo& output,
-                         char* reasonIfUnsupported = nullptr,
-                         size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsBatchNormalizationSupported(const BackendId& backend,
-                                   const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const TensorInfo& mean,
-                                   const TensorInfo& var,
-                                   const TensorInfo& beta,
-                                   const TensorInfo& gamma,
-                                   const BatchNormalizationDescriptor& descriptor,
-                                   char* reasonIfUnsupported = nullptr,
-                                   size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsBatchToSpaceNdSupported(const BackendId& backend,
-                               const TensorInfo& input,
-                               const TensorInfo& output,
-                               const BatchToSpaceNdDescriptor& descriptor,
-                               char* reasonIfUnsupported = nullptr,
-                               size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsConcatSupported(const BackendId& backend,
-                       const std::vector<const TensorInfo*> inputs,
-                       const TensorInfo& output,
-                       const OriginsDescriptor& descriptor,
-                       char* reasonIfUnsupported = nullptr,
-                       size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsConstantSupported(const BackendId& backend,
-                         const TensorInfo& output,
-                         char* reasonIfUnsupported = nullptr,
-                         size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsConvertFp16ToFp32Supported(const BackendId& backend,
-                                  const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  char* reasonIfUnsupported = nullptr,
-                                  size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsConvertFp32ToFp16Supported(const BackendId& backend,
-                                  const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  char* reasonIfUnsupported = nullptr,
-                                  size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsConvolution2dSupported(const BackendId& backend,
-                              const TensorInfo& input,
-                              const TensorInfo& output,
-                              const Convolution2dDescriptor& descriptor,
-                              const TensorInfo& weights,
-                              const Optional<TensorInfo>& biases,
-                              char* reasonIfUnsupported = nullptr,
-                              size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsDebugSupported(const BackendId& backend,
-                      const TensorInfo& input,
-                      const TensorInfo& output,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsDepthwiseConvolutionSupported(const BackendId& backend,
-                                     const TensorInfo& input,
-                                     const TensorInfo& output,
-                                     const DepthwiseConvolution2dDescriptor& descriptor,
-                                     const TensorInfo& weights,
-                                     const Optional<TensorInfo>& biases,
-                                     char* reasonIfUnsupported = nullptr,
-                                     size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsDequantizeSupported(const BackendId& backend,
-                           const TensorInfo& input,
-                           const TensorInfo& output,
-                           char* reasonIfUnsupported = nullptr,
-                           size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsDivisionSupported(const BackendId& backend,
-                         const TensorInfo& input0,
-                         const TensorInfo& input1,
-                         const TensorInfo& output,
-                         char* reasonIfUnsupported = nullptr,
-                         size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsEqualSupported(const BackendId& backend,
-                      const TensorInfo& input0,
-                      const TensorInfo& input1,
-                      const TensorInfo& output,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsFakeQuantizationSupported(const BackendId& backend,
-                                 const TensorInfo& input,
-                                 const FakeQuantizationDescriptor& descriptor,
-                                 char* reasonIfUnsupported = nullptr,
-                                 size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsFloorSupported(const BackendId& backend,
-                      const TensorInfo& input,
-                      const TensorInfo& output,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsFullyConnectedSupported(const BackendId& backend,
-                               const TensorInfo& input,
-                               const TensorInfo& output,
-                               const TensorInfo& weights,
-                               const TensorInfo& biases,
-                               const FullyConnectedDescriptor& descriptor,
-                               char* reasonIfUnsupported = nullptr,
-                               size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsGreaterSupported(const BackendId& backend,
-                        const TensorInfo& input0,
-                        const TensorInfo& input1,
-                        const TensorInfo& output,
-                        char* reasonIfUnsupported = nullptr,
-                        size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsInputSupported(const BackendId& backend,
-                      const TensorInfo& input,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsL2NormalizationSupported(const BackendId& backend,
-                                const TensorInfo& input,
-                                const TensorInfo& output,
-                                const L2NormalizationDescriptor& descriptor,
-                                char* reasonIfUnsupported = nullptr,
-                                size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsLstmSupported(const BackendId& backend, const TensorInfo& input, const TensorInfo& outputStateIn,
-                     const TensorInfo& cellStateIn, const TensorInfo& scratchBuffer,
-                     const TensorInfo& outputStateOut, const TensorInfo& cellStateOut,
-                     const TensorInfo& output, const LstmDescriptor& descriptor,
-                     const LstmInputParamsInfo& paramsInfo, char* reasonIfUnsupported = nullptr,
-                     size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsMaximumSupported(const BackendId& backend,
-                        const TensorInfo& input0,
-                        const TensorInfo& input1,
-                        const TensorInfo& output,
-                        char* reasonIfUnSupported = nullptr,
-                        size_t reasonIfUnSupportedMaxLength = 0);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsMeanSupported(const BackendId& backend,
-                     const TensorInfo& input,
-                     const TensorInfo& output,
-                     const MeanDescriptor& descriptor,
-                     char* reasonIfUnsupported = nullptr,
-                     size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsMemCopySupported(const BackendId& backend,
-                        const TensorInfo& input,
-                        const TensorInfo& output,
-                        char* reasonIfUnsupported = nullptr,
-                        size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsMergeSupported(const BackendId& backend,
-                      const TensorInfo& input0,
-                      const TensorInfo& input1,
-                      const TensorInfo& output,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsMinimumSupported(const BackendId& backend,
-                        const TensorInfo& input0,
-                        const TensorInfo& input1,
-                        const TensorInfo& output,
-                        char* reasonIfUnsupported = nullptr,
-                        size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsMultiplicationSupported(const BackendId& backend,
-                               const TensorInfo& input0,
-                               const TensorInfo& input1,
-                               const TensorInfo& output,
-                               char* reasonIfUnsupported = nullptr,
-                               size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsNormalizationSupported(const BackendId& backend,
-                              const TensorInfo& input,
-                              const TensorInfo& output,
-                              const NormalizationDescriptor& descriptor,
-                              char* reasonIfUnsupported = nullptr,
-                              size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsOutputSupported(const BackendId& backend,
-                       const TensorInfo& output,
-                       char* reasonIfUnsupported = nullptr,
-                       size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsPadSupported(const BackendId& backend,
-                     const TensorInfo& input,
-                     const TensorInfo& output,
-                     const PadDescriptor& descriptor,
-                     char* reasonIfUnsupported = nullptr,
-                     size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsPermuteSupported(const BackendId& backend,
-                        const TensorInfo& input,
-                        const TensorInfo& output,
-                        const PermuteDescriptor& descriptor,
-                        char* reasonIfUnsupported = nullptr,
-                        size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsPreCompiledSupported(const BackendId& backend,
-                            const TensorInfo& input,
-                            char* reasonIfUnsupported = nullptr,
-                            size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsPreluSupported(const BackendId& backend,
-                      const TensorInfo& input,
-                      const TensorInfo& alpha,
-                      const TensorInfo& output,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsPooling2dSupported(const BackendId& backend,
-                          const TensorInfo& input,
-                          const TensorInfo& output,
-                          const Pooling2dDescriptor& descriptor,
-                          char* reasonIfUnsupported = nullptr,
-                          size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsQuantizedLstmSupported(const BackendId& backend,
-                              const TensorInfo& input,
-                              const TensorInfo& previousCellStateIn,
-                              const TensorInfo& previousOutputIn,
-                              const TensorInfo& cellStateOut,
-                              const TensorInfo& output,
-                              const QuantizedLstmInputParamsInfo& paramsInfo,
-                              char* reasonIfUnsupported = nullptr,
-                              size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsReduceSupported(const BackendId& backend,
-                       const TensorInfo& input,
-                       const TensorInfo& output,
-                       const ReduceDescriptor& descriptor,
-                       char* reasonIfUnsupported = nullptr,
-                       size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsReshapeSupported(const BackendId& backend,
-                        const TensorInfo& input,
-                        const ReshapeDescriptor& descriptor,
-                        char* reasonIfUnsupported = nullptr,
-                        size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsResizeSupported(const BackendId& backend,
-                       const TensorInfo& input,
-                       const TensorInfo& output,
-                       const ResizeDescriptor& descriptor,
-                       char* reasonIfUnsupported = nullptr,
-                       size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsRsqrtSupported(const BackendId& backend,
-                      const TensorInfo& input,
-                      const TensorInfo& output,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsSoftmaxSupported(const BackendId& backend,
-                        const TensorInfo& input,
-                        const TensorInfo& output,
-                        const SoftmaxDescriptor& descriptor,
-                        char* reasonIfUnsupported = nullptr,
-                        size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsSpaceToBatchNdSupported(const BackendId& backend,
-                               const TensorInfo& input,
-                               const TensorInfo& output,
-                               const SpaceToBatchNdDescriptor& descriptor,
-                               char* reasonIfUnsupported = nullptr,
-                               size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsSpaceToDepthSupported(const BackendId& backend,
-                             const TensorInfo& input,
-                             const TensorInfo& output,
-                             const SpaceToDepthDescriptor& descriptor,
-                             char* reasonIfUnsupported = nullptr,
-                             size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsSplitterSupported(const BackendId& backend,
-                         const TensorInfo& input,
-                         const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
-                         const ViewsDescriptor& descriptor,
-                         char* reasonIfUnsupported = nullptr,
-                         size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsStackSupported(const BackendId& backend,
-                      const std::vector<const TensorInfo*> inputs,
-                      const TensorInfo& output,
-                      const StackDescriptor& descriptor,
-                      char* reasonIfUnsupported = nullptr,
-                      size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsStridedSliceSupported(const BackendId& backend,
-                             const TensorInfo& input,
-                             const TensorInfo& output,
-                             const StridedSliceDescriptor& descriptor,
-                             char* reasonIfUnsupported = nullptr,
-                             size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsSubtractionSupported(const BackendId& backend,
-                            const TensorInfo& input0,
-                            const TensorInfo& input1,
-                            const TensorInfo& output,
-                            char* reasonIfUnsupported = nullptr,
-                            size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsSwitchSupported(const BackendId& backend,
-                       const TensorInfo& input0,
-                       const TensorInfo& input1,
-                       const TensorInfo& output0,
-                       const TensorInfo& output1,
-                       char* reasonIfUnsupported = nullptr,
-                       size_t reasonIfUnsupportedMaxLength = 1024);
-
-/// Deprecated in favor of IBackend and ILayerSupport interfaces
-bool IsTransposeConvolution2dSupported(const BackendId& backend,
-                                       const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       const TransposeConvolution2dDescriptor& descriptor,
-                                       const TensorInfo& weights,
-                                       const Optional<TensorInfo>& biases,
-                                       char* reasonIfUnsupported = nullptr,
-                                       size_t reasonIfUnsupportedMaxLength = 1024);
-
-}
diff --git a/include/armnn/backends/ILayerSupport.hpp b/include/armnn/backends/ILayerSupport.hpp
index 92102c11ed..6b024e347b 100644
--- a/include/armnn/backends/ILayerSupport.hpp
+++ b/include/armnn/backends/ILayerSupport.hpp
@@ -35,526 +35,6 @@ public:
                                       EmptyOptional(),
                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsActivationSupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       const ActivationDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsAdditionSupported(const TensorInfo& input0,
-                                     const TensorInfo& input1,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsArgMinMaxSupported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      const ArgMinMaxDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsBatchNormalizationSupported(const TensorInfo& input,
-                                               const TensorInfo& output,
-                                               const TensorInfo& mean,
-                                               const TensorInfo& var,
-                                               const TensorInfo& beta,
-                                               const TensorInfo& gamma,
-                                               const BatchNormalizationDescriptor& descriptor,
-                                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsBatchToSpaceNdSupported(const TensorInfo& input,
-                                           const TensorInfo& output,
-                                           const BatchToSpaceNdDescriptor& descriptor,
-                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsCastSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsChannelShuffleSupported(const TensorInfo& input,
-                                           const TensorInfo& output,
-                                           const ChannelShuffleDescriptor& descriptor,
-                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsComparisonSupported(const TensorInfo& input0,
-                                       const TensorInfo& input1,
-                                       const TensorInfo& output,
-                                       const ComparisonDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
-                                   const TensorInfo& output,
-                                   const OriginsDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsConstantSupported(const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsConvertFp16ToFp32Supported(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsConvertFp32ToFp16Supported(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsConvolution2dSupported(const TensorInfo& input,
-                                          const TensorInfo& output,
-                                          const Convolution2dDescriptor& descriptor,
-                                          const TensorInfo& weights,
-                                          const Optional<TensorInfo>& biases,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsConvolution3dSupported(const TensorInfo& input,
-                                          const TensorInfo& output,
-                                          const Convolution3dDescriptor& descriptor,
-                                          const TensorInfo& weights,
-                                          const Optional<TensorInfo>& biases,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsDebugSupported(const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsDepthToSpaceSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const DepthToSpaceDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsDepthwiseConvolutionSupported(
-                     const TensorInfo& input,
-                     const TensorInfo& output,
-                     const DepthwiseConvolution2dDescriptor& descriptor,
-                     const TensorInfo& weights,
-                     const Optional<TensorInfo>& biases,
-                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsDequantizeSupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
-                                                 const TensorInfo& scores,
-                                                 const TensorInfo& anchors,
-                                                 const TensorInfo& detectionBoxes,
-                                                 const TensorInfo& detectionClasses,
-                                                 const TensorInfo& detectionScores,
-                                                 const TensorInfo& numDetections,
-                                                 const DetectionPostProcessDescriptor& descriptor,
-                                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsDilatedDepthwiseConvolutionSupported(
-                    const TensorInfo& input,
-                    const TensorInfo& output,
-                    const DepthwiseConvolution2dDescriptor& descriptor,
-                    const TensorInfo& weights,
-                    const Optional<TensorInfo>& biases,
-                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsDivisionSupported(const TensorInfo& input0,
-                                     const TensorInfo& input1,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsElementwiseUnarySupported(const TensorInfo& input,
-                                             const TensorInfo& output,
-                                             const ElementwiseUnaryDescriptor& descriptor,
-                                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsFakeQuantizationSupported(const TensorInfo& input,
-                                             const FakeQuantizationDescriptor& descriptor,
-                                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsFillSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 const FillDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsFloorSupported(const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsFullyConnectedSupported(const TensorInfo& input,
-                                           const TensorInfo& output,
-                                           const TensorInfo& weights,
-                                           const TensorInfo& biases,
-                                           const FullyConnectedDescriptor& descriptor,
-                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsGatherSupported(const TensorInfo& input0,
-                                   const TensorInfo& input1,
-                                   const TensorInfo& output,
-                                   const GatherDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsInputSupported(const TensorInfo& input,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsInstanceNormalizationSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const InstanceNormalizationDescriptor& descriptor,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsL2NormalizationSupported(const TensorInfo& input,
-                                            const TensorInfo& output,
-                                            const L2NormalizationDescriptor& descriptor,
-                                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsLogicalBinarySupported(const TensorInfo& input0,
-                                          const TensorInfo& input1,
-                                          const TensorInfo& output,
-                                          const LogicalBinaryDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsLogicalUnarySupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const ElementwiseUnaryDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsLogSoftmaxSupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       const LogSoftmaxDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsLstmSupported(const TensorInfo& input,
-                                 const TensorInfo& outputStateIn,
-                                 const TensorInfo& cellStateIn,
-                                 const TensorInfo& scratchBuffer,
-                                 const TensorInfo& outputStateOut,
-                                 const TensorInfo& cellStateOut,
-                                 const TensorInfo& output,
-                                 const LstmDescriptor& descriptor,
-                                 const LstmInputParamsInfo& paramsInfo,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsMaximumSupported(const TensorInfo& input0,
-                                    const TensorInfo& input1,
-                                    const TensorInfo& output,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsMeanSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 const MeanDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsMemCopySupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsMemImportSupported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsMergeSupported(const TensorInfo& input0,
-                                  const TensorInfo& input1,
-                                  const TensorInfo& output,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsMinimumSupported(const TensorInfo& input0,
-                                    const TensorInfo& input1,
-                                    const TensorInfo& ouput,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsMultiplicationSupported(const TensorInfo& input0,
-                                           const TensorInfo& input1,
-                                           const TensorInfo& output,
-                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsNormalizationSupported(const TensorInfo& input,
-                                          const TensorInfo& output,
-                                          const NormalizationDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsOutputSupported(const TensorInfo& output,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsPadSupported(const TensorInfo& input,
-                                const TensorInfo& output,
-                                const PadDescriptor& descriptor,
-                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsPermuteSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    const PermuteDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsPooling2dSupported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      const Pooling2dDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsPooling3dSupported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      const Pooling3dDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsPreCompiledSupported(const TensorInfo& input,
-                                        const PreCompiledDescriptor& descriptor,
-                                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsPreluSupported(const TensorInfo& input,
-                                  const TensorInfo& alpha,
-                                  const TensorInfo& output,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsQuantizeSupported(const TensorInfo& input,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsQLstmSupported(const TensorInfo& input,
-                                  const TensorInfo& previousOutputIn,
-                                  const TensorInfo& previousCellStateIn,
-                                  const TensorInfo& outputStateOut,
-                                  const TensorInfo& cellStateOut,
-                                  const TensorInfo& output,
-                                  const QLstmDescriptor& descriptor,
-                                  const LstmInputParamsInfo& paramsInfo,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsQuantizedLstmSupported(const TensorInfo& input,
-                                          const TensorInfo& previousCellStateIn,
-                                          const TensorInfo& previousOutputIn,
-                                          const TensorInfo& cellStateOut,
-                                          const TensorInfo& output,
-                                          const QuantizedLstmInputParamsInfo& paramsInfo,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsRankSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsReduceSupported(const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const ReduceDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsReshapeSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    const ReshapeDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsResizeSupported(const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const ResizeDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsShapeSupported(const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsSliceSupported(const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  const SliceDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsSoftmaxSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    const SoftmaxDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsSpaceToBatchNdSupported(const TensorInfo& input,
-                                           const TensorInfo& output,
-                                           const SpaceToBatchNdDescriptor& descriptor,
-                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsSpaceToDepthSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const SpaceToDepthDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsSplitterSupported(const TensorInfo& input,
-                                     const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
-                                     const ViewsDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,
-                                  const TensorInfo& output,
-                                  const StackDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsStandInSupported(const std::vector<const TensorInfo*>& inputs,
-                                    const std::vector<const TensorInfo*>& outputs,
-                                    const StandInDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsStridedSliceSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const StridedSliceDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsSubtractionSupported(const TensorInfo& input0,
-                                        const TensorInfo& input1,
-                                        const TensorInfo& output,
-                                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsSwitchSupported(const TensorInfo& input0,
-                                   const TensorInfo& input1,
-                                   const TensorInfo& output0,
-                                   const TensorInfo& output1,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsTransposeConvolution2dSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const TransposeConvolution2dDescriptor& descriptor,
-        const TensorInfo& weights,
-        const Optional<TensorInfo>& biases,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsTransposeSupported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      const TransposeDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. "
-                                      "Use ABI Stable IsLayerSupported accepting LayerType argument instead.", "23.08")
-    virtual bool IsUnidirectionalSequenceLstmSupported(
-        const TensorInfo& input,
-        const TensorInfo& outputStateIn,
-        const TensorInfo& cellStateIn,
-        const TensorInfo& outputStateOut,
-        const TensorInfo& cellStateOut,
-        const TensorInfo& output,
-        const LstmDescriptor& descriptor,
-        const LstmInputParamsInfo& paramsInfo,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
-
 }; // class ILayerSupport
 
 using ILayerSupportSharedPtr = std::shared_ptr<ILayerSupport>;
diff --git a/include/armnnTestUtils/MockBackend.hpp b/include/armnnTestUtils/MockBackend.hpp
index 05df1b46b1..3c79e16220 100644
--- a/include/armnnTestUtils/MockBackend.hpp
+++ b/include/armnnTestUtils/MockBackend.hpp
@@ -331,13 +331,13 @@ public:
     }
 
     bool IsInputSupported(const TensorInfo& /*input*/,
-                          Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const override
+                          Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const
     {
         return true;
     }
 
     bool IsOutputSupported(const TensorInfo& /*input*/,
-                           Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const override
+                           Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const
     {
         return true;
     }
@@ -345,7 +345,7 @@ public:
     bool IsAdditionSupported(const TensorInfo& /*input0*/,
                              const TensorInfo& /*input1*/,
                              const TensorInfo& /*output*/,
-                             Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const override
+                             Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const
     {
         return true;
     }
@@ -355,7 +355,7 @@ public:
                                   const Convolution2dDescriptor& /*descriptor*/,
                                   const TensorInfo& /*weights*/,
                                   const Optional<TensorInfo>& /*biases*/,
-                                  Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const override
+                                  Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const
     {
         return true;
     }
diff --git a/include/armnnTestUtils/Version.hpp b/include/armnnTestUtils/Version.hpp
index d7a8cd6164..a1c2e58009 100644
--- a/include/armnnTestUtils/Version.hpp
+++ b/include/armnnTestUtils/Version.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -10,7 +10,7 @@
 #define STRINGIFY_MACRO(s) #s
 
 // ArmnnTestUtils version components
-#define ARMNN_TEST_UTILS_MAJOR_VERSION 2
+#define ARMNN_TEST_UTILS_MAJOR_VERSION 3
 #define ARMNN_TEST_UTILS_MINOR_VERSION 0
 #define ARMNN_TEST_UTILS_PATCH_VERSION 0
 
diff --git a/src/armnn/ILayerSupport.cpp b/src/armnn/ILayerSupport.cpp
index 3ef367ee16..9610ca1df9 100644
--- a/src/armnn/ILayerSupport.cpp
+++ b/src/armnn/ILayerSupport.cpp
@@ -12,9 +12,8 @@
 namespace armnn
 {
 
-ARMNN_NO_DEPRECATE_WARN_BEGIN
-// IsLayerSupported() forwards to the deprecated virtual methods depending on input LayerType.
-// Allows backends continue to behave as before maintaining backward compatibility.
+/// Default implementation of the ILayerSupport interface, Backends should implement this as a switch statement
+/// for each of their LayerTypes calling their specific backend implementation of IsXXXLayerSupported.
 bool ILayerSupport::IsLayerSupported(const LayerType& type,
                                      const std::vector<TensorInfo>& infos,
                                      const BaseDescriptor& descriptor,
@@ -22,1220 +21,20 @@ bool ILayerSupport::IsLayerSupported(const LayerType& type,
                                      const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,
                                      Optional<std::string&> reasonIfUnsupported) const
 {
+    IgnoreUnused(infos);
+    IgnoreUnused(descriptor);
+    IgnoreUnused(lstmParamsInfo);
+    IgnoreUnused(quantizedLstmParamsInfo);
+    IgnoreUnused(reasonIfUnsupported);
     switch (type)
     {
-        case LayerType::Activation:
-            return IsActivationSupported(infos[0],
-                                         infos[1],
-                                         *(PolymorphicDowncast<const ActivationDescriptor*>(&descriptor)),
-                                         reasonIfUnsupported);
-        case LayerType::Addition:
-            return IsAdditionSupported(infos[0],
-                                       infos[1],
-                                       infos[2],
-                                       reasonIfUnsupported);
-        case LayerType::ArgMinMax:
-            return IsArgMinMaxSupported(infos[0],
-                                        infos[1],
-                                        *(PolymorphicDowncast<const ArgMinMaxDescriptor*>(&descriptor)),
-                                        reasonIfUnsupported);
-        case LayerType::BatchNormalization:
-            return IsBatchNormalizationSupported(infos[0],
-                                                 infos[1],
-                                                 infos[2],
-                                                 infos[3],
-                                                 infos[4],
-                                                 infos[5],
-                                                 *(PolymorphicDowncast<const BatchNormalizationDescriptor*>
-                                                     (&descriptor)),
-                                                 reasonIfUnsupported);
-        case LayerType::BatchToSpaceNd:
-            return IsBatchToSpaceNdSupported(infos[0],
-                                             infos[1],
-                                             *(PolymorphicDowncast<const BatchToSpaceNdDescriptor*>(&descriptor)),
-                                             reasonIfUnsupported);
-        case LayerType::Comparison:
-        {
-            return IsComparisonSupported(infos[0],
-                                         infos[1],
-                                         infos[2],
-                                         *(PolymorphicDowncast<const ComparisonDescriptor*>(&descriptor)),
-                                         reasonIfUnsupported);
-        }
-        case LayerType::Concat:
-        {
-            std::vector<const TensorInfo*> inputInfos;
-            for (uint32_t i = 0; i < (infos.size() - 1); i++)
-            {
-                inputInfos.push_back(&infos[i]);
-            }
-            return IsConcatSupported(inputInfos,
-                                     infos[infos.size() - 1],
-                                     *(PolymorphicDowncast<const OriginsDescriptor*>(&descriptor)),
-                                     reasonIfUnsupported);
-        }
-        case LayerType::Constant:
-            return IsConstantSupported(infos[0],
-                                       reasonIfUnsupported);
-        case LayerType::ConvertFp16ToFp32:
-            return IsConvertFp16ToFp32Supported(infos[0],
-                                                infos[1],
-                                                reasonIfUnsupported);
-        case LayerType::ConvertFp32ToFp16:
-            return IsConvertFp32ToFp16Supported(infos[0],
-                                                infos[1],
-                                                reasonIfUnsupported);
-        case LayerType::Convolution2d:
-        {
-            if (infos.size() != 4)
-            {
-                throw InvalidArgumentException("Invalid number of Convolution2d "
-                                               "TensorInfos. TensorInfos should be of format: "
-                                               "{input, output, weights, biases}.");
-            }
-
-            auto desc = *(PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor));
-            if (infos[3] == TensorInfo())
-            {
-                return IsConvolution2dSupported(infos[0],
-                                                infos[1],
-                                                desc,
-                                                infos[2],
-                                                EmptyOptional(),
-                                                reasonIfUnsupported);
-            }
-            else
-            {
-                return IsConvolution2dSupported(infos[0],
-                                                infos[1],
-                                                desc,
-                                                infos[2],
-                                                infos[3],
-                                                reasonIfUnsupported);
-            }
-        }
-        case LayerType::Debug:
-            return IsDebugSupported(infos[0],
-                                    infos[1],
-                                    reasonIfUnsupported);
-        case LayerType::DepthToSpace:
-            return IsDepthToSpaceSupported(infos[0],
-                                           infos[1],
-                                           *(PolymorphicDowncast<const DepthToSpaceDescriptor*>(&descriptor)),
-                                           reasonIfUnsupported);
-        case LayerType::DepthwiseConvolution2d:
-        {
-            if (infos.size() != 4)
-            {
-                throw InvalidArgumentException("Invalid number of DepthwiseConvolution2d "
-                                               "TensorInfos. TensorInfos should be of format: "
-                                               "{input, output, weights, biases}.");
-            }
-
-            auto desc = *(PolymorphicDowncast<const DepthwiseConvolution2dDescriptor*>(&descriptor));
-            if (infos[3] == TensorInfo())
-            {
-                return IsDepthwiseConvolutionSupported(infos[0],
-                                                       infos[1],
-                                                       desc,
-                                                       infos[2],
-                                                       EmptyOptional(),
-                                                       reasonIfUnsupported);
-            }
-            else
-            {
-                return IsDepthwiseConvolutionSupported(infos[0],
-                                                       infos[1],
-                                                       desc,
-                                                       infos[2],
-                                                       infos[3],
-                                                       reasonIfUnsupported);
-            }
-        }
-        case LayerType::Dequantize:
-            return IsDequantizeSupported(infos[0],
-                                         infos[1],
-                                         reasonIfUnsupported);
-        case LayerType::DetectionPostProcess:
-            return IsDetectionPostProcessSupported(infos[0],
-                                                   infos[1],
-                                                   infos[2],
-                                                   infos[3],
-                                                   infos[4],
-                                                   infos[5],
-                                                   infos[6],
-                                                   *(PolymorphicDowncast<const DetectionPostProcessDescriptor*>
-                                                       (&descriptor)),
-                                                   reasonIfUnsupported);
-        case LayerType::Division:
-            return IsDivisionSupported(infos[0],
-                                       infos[1],
-                                       infos[2],
-                                       reasonIfUnsupported);
-        case LayerType::ElementwiseUnary:
-            return IsElementwiseUnarySupported(infos[0],
-                                               infos[1],
-                                               *(PolymorphicDowncast<const ElementwiseUnaryDescriptor*>
-                                                   (&descriptor)),
-                                               reasonIfUnsupported);
-        case LayerType::FakeQuantization:
-            return IsFakeQuantizationSupported(infos[0],
-                                               *(PolymorphicDowncast<const FakeQuantizationDescriptor*>
-                                                   (&descriptor)),
-                                               reasonIfUnsupported);
-        case LayerType::Fill:
-            return IsFillSupported(infos[0],
-                                   infos[1],
-                                   *(PolymorphicDowncast<const FillDescriptor*>(&descriptor)),
-                                   reasonIfUnsupported);
-        case LayerType::Floor:
-            return IsFloorSupported(infos[0], infos[1], reasonIfUnsupported);
-        case LayerType::FullyConnected:
-            return IsFullyConnectedSupported(infos[0],
-                                             infos[1],
-                                             infos[2],
-                                             infos[3],
-                                             *(PolymorphicDowncast<const FullyConnectedDescriptor*>(&descriptor)),
-                                             reasonIfUnsupported);
-        case LayerType::Gather:
-            return IsGatherSupported(infos[0],
-                                     infos[1],
-                                     infos[2],
-                                     *(PolymorphicDowncast<const GatherDescriptor*>(&descriptor)),
-                                     reasonIfUnsupported);
-        case LayerType::Input:
-            return IsInputSupported(infos[0], reasonIfUnsupported);
-        case LayerType::InstanceNormalization:
-            return IsInstanceNormalizationSupported(infos[0],
-                                                    infos[1],
-                                                    *(PolymorphicDowncast<const InstanceNormalizationDescriptor*>
-                                                        (&descriptor)),
-                                                    reasonIfUnsupported);
-        case LayerType::L2Normalization:
-            return IsL2NormalizationSupported(infos[0],
-                                              infos[1],
-                                              *(PolymorphicDowncast<const L2NormalizationDescriptor*>
-                                                  (&descriptor)),
-                                              reasonIfUnsupported);
-        case LayerType::LogicalBinary:
-            return IsLogicalBinarySupported(infos[0],
-                                            infos[1],
-                                            infos[2],
-                                            *(PolymorphicDowncast<const LogicalBinaryDescriptor*>(&descriptor)),
-                                            reasonIfUnsupported);
-        case LayerType::LogSoftmax:
-            return IsLogSoftmaxSupported(infos[0],
-                                         infos[1],
-                                         *(PolymorphicDowncast<const LogSoftmaxDescriptor*>(&descriptor)),
-                                         reasonIfUnsupported);
-        case LayerType::Lstm:
-            return IsLstmSupported(infos[0],
-                                   infos[1],
-                                   infos[2],
-                                   infos[3],
-                                   infos[4],
-                                   infos[5],
-                                   infos[6],
-                                   *(PolymorphicDowncast<const LstmDescriptor*>(&descriptor)),
-                                   lstmParamsInfo.value(),
-                                   reasonIfUnsupported);
-        case LayerType::QLstm:
-            return IsQLstmSupported(infos[0],
-                                    infos[1],
-                                    infos[2],
-                                    infos[3],
-                                    infos[4],
-                                    infos[5],
-                                    *(PolymorphicDowncast<const QLstmDescriptor*>(&descriptor)),
-                                    lstmParamsInfo.value(),
-                                    reasonIfUnsupported);
         case LayerType::Map:
             return true;
-        case LayerType::Maximum:
-            return IsMaximumSupported(infos[0],
-                                      infos[1],
-                                      infos[2],
-                                      reasonIfUnsupported);
-        case LayerType::Mean:
-            return IsMeanSupported(infos[0],
-                                   infos[1],
-                                   *(PolymorphicDowncast<const MeanDescriptor*>(&descriptor)),
-                                   reasonIfUnsupported);
-        case LayerType::MemCopy:
-            return IsMemCopySupported(std::move(infos[0]),
-                                      std::move(infos[1]),
-                                      reasonIfUnsupported);
-        case LayerType::MemImport:
-            return IsMemImportSupported(infos[0],
-                                        infos[1],
-                                        reasonIfUnsupported);
-        case LayerType::Merge:
-            return IsMergeSupported(infos[0],
-                                    infos[1],
-                                    infos[2],
-                                    reasonIfUnsupported);
-        case LayerType::Minimum:
-            return IsMinimumSupported(infos[0],
-                                      infos[1],
-                                      infos[2],
-                                      reasonIfUnsupported);
-        case LayerType::Multiplication:
-            return IsMultiplicationSupported(infos[0],
-                                             infos[1],
-                                             infos[2],
-                                             reasonIfUnsupported);
-        case LayerType::Normalization:
-            return IsNormalizationSupported(infos[0],
-                                            infos[1],
-                                            *(PolymorphicDowncast<const NormalizationDescriptor*>(&descriptor)),
-                                            reasonIfUnsupported);
-        case LayerType::Output:
-            return IsOutputSupported(infos[0], reasonIfUnsupported);
-        case LayerType::Pad:
-            return IsPadSupported(infos[0],
-                                  infos[1],
-                                  *(PolymorphicDowncast<const PadDescriptor*>(&descriptor)),
-                                  reasonIfUnsupported);
-        case LayerType::Permute:
-            return IsPermuteSupported(infos[0],
-                                      infos[1],
-                                      *(PolymorphicDowncast<const PermuteDescriptor*>(&descriptor)),
-                                      reasonIfUnsupported);
-        case LayerType::Pooling2d:
-            return IsPooling2dSupported(infos[0],
-                                        infos[1],
-                                        *(PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor)),
-                                        reasonIfUnsupported);
-        case LayerType::PreCompiled:
-            return IsPreCompiledSupported(infos[0],
-                                          *(PolymorphicDowncast<const PreCompiledDescriptor*>(&descriptor)),
-                                          reasonIfUnsupported);
-        case LayerType::Prelu:
-            return IsPreluSupported(infos[0],
-                                    infos[1],
-                                    infos[2],
-                                    reasonIfUnsupported);
-        case LayerType::Quantize:
-            return IsQuantizeSupported(infos[0],
-                                       infos[1],
-                                       reasonIfUnsupported);
-        case LayerType::QuantizedLstm:
-            return IsQuantizedLstmSupported(infos[0],
-                                            infos[1],
-                                            infos[2],
-                                            infos[3],
-                                            infos[4],
-                                            quantizedLstmParamsInfo.value(),
-                                            reasonIfUnsupported);
-        case LayerType::Reshape:
-            return IsReshapeSupported(infos[0],
-                                      infos[1],
-                                      *(PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor)),
-                                      reasonIfUnsupported);
-        case LayerType::Rank:
-            return IsRankSupported(infos[0], infos[1], reasonIfUnsupported);
-        case LayerType::Resize:
-            return IsResizeSupported(infos[0],
-                                     infos[1],
-                                     *(PolymorphicDowncast<const ResizeDescriptor*>(&descriptor)),
-                                     reasonIfUnsupported);
-        case LayerType::Reduce:
-            return IsReduceSupported(infos[0],
-                                     infos[1],
-                                     *(PolymorphicDowncast<const ReduceDescriptor*>(&descriptor)),
-                                     reasonIfUnsupported);
-        case LayerType::Slice:
-            return IsSliceSupported(infos[0],
-                                    infos[1],
-                                    *(PolymorphicDowncast<const SliceDescriptor*>(&descriptor)),
-                                    reasonIfUnsupported);
-        case LayerType::Softmax:
-            return IsSoftmaxSupported(infos[0],
-                                      infos[1],
-                                      *(PolymorphicDowncast<const SoftmaxDescriptor*>(&descriptor)),
-                                      reasonIfUnsupported);
-        case LayerType::SpaceToBatchNd:
-            return IsSpaceToBatchNdSupported(infos[0],
-                                             infos[1],
-                                             *(PolymorphicDowncast<const SpaceToBatchNdDescriptor*>(&descriptor)),
-                                             reasonIfUnsupported);
-        case LayerType::SpaceToDepth:
-            return IsSpaceToDepthSupported(infos[0],
-                                           infos[1],
-                                           *(PolymorphicDowncast<const SpaceToDepthDescriptor*>(&descriptor)),
-                                           reasonIfUnsupported);
-        case LayerType::Splitter:
-        {
-            std::vector<TensorInfo> outputInfos;
-            for (uint32_t i = 1; i < infos.size(); i++)
-            {
-                outputInfos.push_back(infos[i]);
-            }
-            return IsSplitterSupported(infos[0],
-                                       {outputInfos.begin(), outputInfos.end()},
-                                       *(PolymorphicDowncast<const ViewsDescriptor*>(&descriptor)),
-                                       reasonIfUnsupported);
-        }
-        case LayerType::Stack:
-        {
-            std::vector<const TensorInfo*> inputInfos;
-            for (uint32_t i = 0; i < infos.size() - 1; i++)
-            {
-                inputInfos.push_back(&infos[i]);
-            }
-            return IsStackSupported(inputInfos,
-                                    infos[infos.size() - 1],
-                                    *(PolymorphicDowncast<const StackDescriptor*>(&descriptor)),
-                                    reasonIfUnsupported);
-        }
-        case LayerType::StandIn:
-        {
-            auto desc = *(PolymorphicDowncast<const StandInDescriptor*>(&descriptor));
-
-            if (infos.size() != (desc.m_NumInputs + desc.m_NumOutputs))
-            {
-                throw InvalidArgumentException("Number of StandIn layer TensorInfos does not equal "
-                                               "the combined number of input and output slots assigned "
-                                               "to the StandIn descriptor");
-            }
-
-            std::vector<const TensorInfo*> inputInfos;
-            for (uint32_t i = 0; i < desc.m_NumInputs; i++)
-            {
-                inputInfos.push_back(&infos[i]);
-            }
-            std::vector<const TensorInfo*> outputInfos;
-            for (uint32_t i = desc.m_NumInputs; i < infos.size(); i++)
-            {
-                outputInfos.push_back(&infos[i]);
-            }
-
-            return IsStandInSupported(inputInfos,
-                                      outputInfos,
-                                      desc,
-                                      reasonIfUnsupported);
-        }
-        case LayerType::StridedSlice:
-            return IsStridedSliceSupported(infos[0],
-                                           infos[1],
-                                           *(PolymorphicDowncast<const StridedSliceDescriptor*>(&descriptor)),
-                                           reasonIfUnsupported);
-        case LayerType::Subtraction:
-            return IsSubtractionSupported(infos[0],
-                                          infos[1],
-                                          infos[2],
-                                          reasonIfUnsupported);
-        case LayerType::Switch:
-            return IsSwitchSupported(infos[0],
-                                     infos[1],
-                                     infos[2],
-                                     infos[3],
-                                     reasonIfUnsupported);
-        case LayerType::Transpose:
-            return IsTransposeSupported(infos[0],
-                                        infos[1],
-                                        *(PolymorphicDowncast<const TransposeDescriptor*>(&descriptor)),
-                                        reasonIfUnsupported);
-        case LayerType::TransposeConvolution2d:
-        {
-            if (infos.size() != 4)
-            {
-                throw InvalidArgumentException("Invalid number of TransposeConvolution2d "
-                                               "TensorInfos. TensorInfos should be of format: "
-                                               "{input, output, weights, biases}.");
-            }
-
-            auto desc = *(PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor));
-            if (infos[3] == TensorInfo())
-            {
-                return IsTransposeConvolution2dSupported(infos[0],
-                                                         infos[1],
-                                                         desc,
-                                                         infos[2],
-                                                         EmptyOptional(),
-                                                         reasonIfUnsupported);
-            }
-            else
-            {
-                return IsTransposeConvolution2dSupported(infos[0],
-                                                         infos[1],
-                                                         desc,
-                                                         infos[2],
-                                                         infos[3],
-                                                         reasonIfUnsupported);
-            }
-        }
         case LayerType::Unmap:
             return true;
-        case LayerType::Cast:
-            return IsCastSupported(infos[0], infos[1], reasonIfUnsupported);
-        case LayerType::Shape:
-            return IsShapeSupported(infos[0], infos[1], reasonIfUnsupported);
-        case LayerType::UnidirectionalSequenceLstm:
-        {
-            if (infos.size() != 6)
-            {
-                throw InvalidArgumentException("Invalid number of TransposeConvolution2d TensorInfos. TensorInfos "
-                                               "should be of format: {input, outputStateIn, cellStateIn, "
-                                               "hiddenStateOutputVal, cellStateOutputVal, output}");
-            }
-            auto desc = *(PolymorphicDowncast<const UnidirectionalSequenceLstmDescriptor*>(&descriptor));
-            return IsUnidirectionalSequenceLstmSupported(infos[0],
-                                                         infos[1],
-                                                         infos[2],
-                                                         infos[3],
-                                                         infos[4],
-                                                         infos[5],
-                                                         desc,
-                                                         lstmParamsInfo.value(),
-                                                         reasonIfUnsupported);
-        }
-        case LayerType::ChannelShuffle:
-            return IsChannelShuffleSupported(infos[0],
-                                             infos[1],
-                                             *(PolymorphicDowncast<const ChannelShuffleDescriptor*>(&descriptor)),
-                                             reasonIfUnsupported);
-        case LayerType::Convolution3d:
-        {
-            if (infos.size() != 4)
-            {
-                throw InvalidArgumentException("Invalid number of Convolution3d "
-                                               "TensorInfos. TensorInfos should be of format: "
-                                               "{input, output, weights, biases}.");
-            }
-
-            auto desc = *(PolymorphicDowncast<const Convolution3dDescriptor*>(&descriptor));
-            if (infos[3] == TensorInfo())
-            {
-                return IsConvolution3dSupported(infos[0],
-                                                infos[1],
-                                                desc,
-                                                infos[2],
-                                                EmptyOptional(),
-                                                reasonIfUnsupported);
-            }
-            else
-            {
-                return IsConvolution3dSupported(infos[0],
-                                                infos[1],
-                                                desc,
-                                                infos[2],
-                                                infos[3],
-                                                reasonIfUnsupported);
-            }
-        }
-        case LayerType::Pooling3d:
-            return IsPooling3dSupported(infos[0],
-                                        infos[1],
-                                        *(PolymorphicDowncast<const Pooling3dDescriptor*>(&descriptor)),
-                                        reasonIfUnsupported);
         default:
             return false;
     }
 }
 
-bool ILayerSupport::IsActivationSupported(const TensorInfo& input,
-                                          const TensorInfo& output,
-                                          const ActivationDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsAdditionSupported(const TensorInfo& input0,
-                                        const TensorInfo& input1,
-                                        const TensorInfo& output,
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsArgMinMaxSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const ArgMinMaxDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
-                                                  const TensorInfo& output,
-                                                  const TensorInfo& mean,
-                                                  const TensorInfo& var,
-                                                  const TensorInfo& beta,
-                                                  const TensorInfo& gamma,
-                                                  const BatchNormalizationDescriptor& descriptor,
-                                                  Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, mean, var, beta, gamma, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              const BatchToSpaceNdDescriptor& descriptor,
-                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsCastSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsChannelShuffleSupported(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              const ChannelShuffleDescriptor& descriptor,
-                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsComparisonSupported(const TensorInfo& input0,
-                                          const TensorInfo& input1,
-                                          const TensorInfo& output,
-                                          const ComparisonDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
-                                      const TensorInfo& output,
-                                      const OriginsDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsConstantSupported(const TensorInfo& output,
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
-                                                 const TensorInfo& output,
-                                                 Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
-                                                 const TensorInfo& output,
-                                                 Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsConvolution2dSupported(const TensorInfo& input,
-                                             const TensorInfo& output,
-                                             const Convolution2dDescriptor& descriptor,
-                                             const TensorInfo& weights,
-                                             const Optional<TensorInfo>& biases,
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsConvolution3dSupported(const TensorInfo& input,
-                                             const TensorInfo& output,
-                                             const Convolution3dDescriptor& descriptor,
-                                             const TensorInfo& weights,
-                                             const Optional<TensorInfo>& biases,
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsDebugSupported(const TensorInfo& input,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
-                                            const TensorInfo& output,
-                                            const DepthToSpaceDescriptor& descriptor,
-                                            Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsDepthwiseConvolutionSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const DepthwiseConvolution2dDescriptor& descriptor,
-        const TensorInfo& weights,
-        const Optional<TensorInfo>& biases,
-        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input,
-                 output,
-                 descriptor,
-                 weights,
-                 biases,
-                 reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsDequantizeSupported(const TensorInfo& input,
-                                          const TensorInfo& output,
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
-                                                    const TensorInfo& scores,
-                                                    const TensorInfo& anchors,
-                                                    const TensorInfo& detectionBoxes,
-                                                    const TensorInfo& detectionClasses,
-                                                    const TensorInfo& detectionScores,
-                                                    const TensorInfo& numDetections,
-                                                    const DetectionPostProcessDescriptor& descriptor,
-                                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(boxEncodings,
-                 scores,
-                 anchors,
-                 detectionBoxes,
-                 detectionClasses,
-                 detectionScores,
-                 numDetections,
-                 descriptor,
-                 reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsDilatedDepthwiseConvolutionSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const DepthwiseConvolution2dDescriptor& descriptor,
-        const TensorInfo& weights,
-        const Optional<TensorInfo>& biases,
-        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsDivisionSupported(const TensorInfo& input0,
-                                        const TensorInfo& input1,
-                                        const TensorInfo& output,
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
-                                                const TensorInfo& output,
-                                                const ElementwiseUnaryDescriptor& descriptor,
-                                                Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
-                                                const FakeQuantizationDescriptor& descriptor,
-                                                Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsFillSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    const FillDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsFloorSupported(const TensorInfo& input,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              const TensorInfo& weights,
-                                              const TensorInfo& biases,
-                                              const FullyConnectedDescriptor& descriptor,
-                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, weights, biases, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsGatherSupported(const TensorInfo& input0,
-                                      const TensorInfo& input1,
-                                      const TensorInfo& output,
-                                      const GatherDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsInputSupported(const TensorInfo& input,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsInstanceNormalizationSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const InstanceNormalizationDescriptor& descriptor,
-        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
-                                               const TensorInfo& output,
-                                               const L2NormalizationDescriptor& descriptor,
-                                               Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsLogicalBinarySupported(const TensorInfo& input0,
-                                             const TensorInfo& input1,
-                                             const TensorInfo& output,
-                                             const LogicalBinaryDescriptor& descriptor,
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsLogicalUnarySupported(const TensorInfo& input,
-                                            const TensorInfo& output,
-                                            const ElementwiseUnaryDescriptor& descriptor,
-                                            Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
-                                          const TensorInfo& output,
-                                          const LogSoftmaxDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsLstmSupported(const TensorInfo& input,
-                                    const TensorInfo& outputStateIn,
-                                    const TensorInfo& cellStateIn,
-                                    const TensorInfo& scratchBuffer,
-                                    const TensorInfo& outputStateOut,
-                                    const TensorInfo& cellStateOut,
-                                    const TensorInfo& output,
-                                    const LstmDescriptor& descriptor,
-                                    const LstmInputParamsInfo& paramsInfo,
-                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input,
-                 outputStateIn,
-                 cellStateIn,
-                 scratchBuffer,
-                 outputStateOut,
-                 cellStateOut,
-                 output,
-                 descriptor,
-                 paramsInfo,
-                 reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsMaximumSupported(const TensorInfo& input0,
-                                       const TensorInfo& input1,
-                                       const TensorInfo& output,
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsMeanSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    const MeanDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsMemCopySupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsMemImportSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsMergeSupported(const TensorInfo& input0,
-                                     const TensorInfo& input1,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsMinimumSupported(const TensorInfo& input0,
-                                       const TensorInfo& input1,
-                                       const TensorInfo& output,
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
-                                              const TensorInfo& input1,
-                                              const TensorInfo& output,
-                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsNormalizationSupported(const TensorInfo& input,
-                                             const TensorInfo& output,
-                                             const NormalizationDescriptor& descriptor,
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsOutputSupported(const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsPadSupported(const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const PadDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsPermuteSupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       const PermuteDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsPooling2dSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const Pooling2dDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsPooling3dSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const Pooling3dDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsPreCompiledSupported(const TensorInfo& input,
-                                           const PreCompiledDescriptor& descriptor,
-                                           Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsPreluSupported(const TensorInfo& input,
-                                     const TensorInfo& alpha,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, alpha, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsQuantizeSupported(const TensorInfo& input,
-                                        const TensorInfo& output,
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsQLstmSupported(const TensorInfo& input,
-                                     const TensorInfo& previousOutputIn,
-                                     const TensorInfo& previousCellStateIn,
-                                     const TensorInfo& outputStateOut,
-                                     const TensorInfo& cellStateOut,
-                                     const TensorInfo& output,
-                                     const QLstmDescriptor& descriptor,
-                                     const LstmInputParamsInfo& paramsInfo,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input,
-                 previousOutputIn,
-                 previousCellStateIn,
-                 outputStateOut,
-                 cellStateOut,
-                 output,
-                 descriptor,
-                 paramsInfo,
-                 reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsQuantizedLstmSupported(const TensorInfo& input,
-                                             const TensorInfo& previousCellStateIn,
-                                             const TensorInfo& previousOutputIn,
-                                             const TensorInfo& cellStateOut,
-                                             const TensorInfo& output,
-                                             const QuantizedLstmInputParamsInfo& paramsInfo,
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input,
-                 previousCellStateIn,
-                 previousOutputIn,
-                 cellStateOut,
-                 output,
-                 paramsInfo,
-                 reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsRankSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsReduceSupported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      const ReduceDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsReshapeSupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       const ReshapeDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsResizeSupported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      const ResizeDescriptor& descriptor,
-                                      Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsShapeSupported(const TensorInfo& input,
-                                     const TensorInfo& output,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsSliceSupported(const TensorInfo& input,
-                                     const TensorInfo& output,
-                                     const SliceDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsSoftmaxSupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       const SoftmaxDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              const SpaceToBatchNdDescriptor& descriptor,
-                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
-                                            const TensorInfo& output,
-                                            const SpaceToDepthDescriptor& descriptor,
-                                            Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsSplitterSupported(const TensorInfo& input,
-                                        const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
-                                        const ViewsDescriptor& descriptor,
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, outputs, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
-                                     const TensorInfo& output,
-                                     const StackDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(inputs, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsStandInSupported(const std::vector<const TensorInfo*>& inputs,
-                                       const std::vector<const TensorInfo*>& outputs,
-                                       const StandInDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(inputs, outputs, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsStridedSliceSupported(const TensorInfo& input,
-                                            const TensorInfo& output,
-                                            const StridedSliceDescriptor& descriptor,
-                                            Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsSubtractionSupported(const TensorInfo& input0,
-                                           const TensorInfo& input1,
-                                           const TensorInfo& output,
-                                           Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsSwitchSupported(const TensorInfo& input0,
-                                      const TensorInfo& input1,
-                                      const TensorInfo& output0,
-                                      const TensorInfo& output1,
-                                      Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input0, input1, output0, output1, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsTransposeConvolution2dSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const TransposeConvolution2dDescriptor& descriptor,
-        const TensorInfo& weights,
-        const Optional<TensorInfo>& biases,
-        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, weights, biases, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsTransposeSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const TransposeDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input, output, descriptor, reasonIfUnsupported);
-    return false;
-}
-
-bool ILayerSupport::IsUnidirectionalSequenceLstmSupported(
-        const TensorInfo& input,
-        const TensorInfo& outputStateIn,
-        const TensorInfo& cellStateIn,
-        const TensorInfo& outputStateOut,
-        const TensorInfo& cellStateOut,
-        const TensorInfo& output,
-        const LstmDescriptor& descriptor,
-        const LstmInputParamsInfo& paramsInfo,
-        Optional<std::string&> reasonIfUnsupported) const
-{
-    IgnoreUnused(input,
-                 outputStateIn,
-                 cellStateIn,
-                 outputStateOut,
-                 cellStateOut,
-                 output,
-                 descriptor,
-                 paramsInfo,
-                 reasonIfUnsupported);
-    return false;
-}
-ARMNN_NO_DEPRECATE_WARN_END
 }
diff --git a/src/armnn/test/OptimizerTests.cpp b/src/armnn/test/OptimizerTests.cpp
index de077c19f0..2e1ceb5136 100644
--- a/src/armnn/test/OptimizerTests.cpp
+++ b/src/armnn/test/OptimizerTests.cpp
@@ -166,13 +166,13 @@ public:
     }
 
     bool IsInputSupported(const TensorInfo& /*input*/,
-                          Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const override
+                          Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const
     {
         return true;
     }
 
     bool IsOutputSupported(const TensorInfo& /*input*/,
-                           Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const override
+                           Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const
     {
         return true;
     }
@@ -180,7 +180,7 @@ public:
     bool IsActivationSupported(const TensorInfo& /*input0*/,
                                const TensorInfo& /*output*/,
                                const ActivationDescriptor& /*descriptor*/,
-                               Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const override
+                               Optional<std::string&> /*reasonIfUnsupported = EmptyOptional()*/) const
     {
         return true;
     }
diff --git a/src/armnnTfLiteParser/TfLiteParser.cpp b/src/armnnTfLiteParser/TfLiteParser.cpp
index 894da6ab5e..301989ebb7 100644
--- a/src/armnnTfLiteParser/TfLiteParser.cpp
+++ b/src/armnnTfLiteParser/TfLiteParser.cpp
@@ -18,7 +18,6 @@
 #include <armnn/utility/Assert.hpp>
 #include <armnn/utility/IgnoreUnused.hpp>
 #include <armnn/utility/NumericCast.hpp>
-#include <armnn/LayerSupport.hpp>
 
 // armnnUtils:
 #include <armnnUtils/Permute.hpp>
diff --git a/src/backends/backendsCommon/LayerSupportBase.cpp b/src/backends/backendsCommon/LayerSupportBase.cpp
index 26137f51b0..69b980d56f 100644
--- a/src/backends/backendsCommon/LayerSupportBase.cpp
+++ b/src/backends/backendsCommon/LayerSupportBase.cpp
@@ -82,154 +82,6 @@ bool LayerSupportBase::IsLayerSupported(const LayerType& type,
     }
 }
 
-bool LayerSupportBase::IsActivationSupported(const TensorInfo&, // input
-                                             const TensorInfo&, //output
-                                             const ActivationDescriptor&, // descriptor
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsAdditionSupported(const TensorInfo&, // input0
-                                           const TensorInfo&, // input1
-                                           const TensorInfo&, // output
-                                           Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsArgMinMaxSupported(const armnn::TensorInfo&, // input
-                                            const armnn::TensorInfo&, // output
-                                            const armnn::ArgMinMaxDescriptor&, // descriptor
-                                            armnn::Optional<std::string &> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsBatchNormalizationSupported(const TensorInfo&, //input
-                                                     const TensorInfo&, // output
-                                                     const TensorInfo&, //mean
-                                                     const TensorInfo&, //var
-                                                     const TensorInfo&, //beta
-                                                     const TensorInfo&, //gamma
-                                                     const BatchNormalizationDescriptor&, // descriptor
-                                                     Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsBatchToSpaceNdSupported(const TensorInfo&, // input
-                                                 const TensorInfo&, // output
-                                                 const BatchToSpaceNdDescriptor&, //descriptor
-                                                 Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsCastSupported(const TensorInfo&, //input
-                                       const TensorInfo&, //output
-                                       Optional<std::string &> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsChannelShuffleSupported(const TensorInfo&, //input
-                                                 const TensorInfo&, //output
-                                                 const ChannelShuffleDescriptor&, //descriptor
-                                                 Optional<std::string &> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsComparisonSupported(const TensorInfo&, // input0
-                                             const TensorInfo&, // input1
-                                             const TensorInfo&, // output
-                                             const ComparisonDescriptor&, // descriptor
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsConcatSupported(const std::vector<const TensorInfo*>, // inputs
-                                         const TensorInfo&, // output
-                                         const OriginsDescriptor&, // descriptor
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsConstantSupported(const TensorInfo&, // output
-                                           Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsConvertFp16ToFp32Supported(const TensorInfo&, // input
-                                                    const TensorInfo&, // output
-                                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsConvertFp32ToFp16Supported(const TensorInfo&, // input
-                                                    const TensorInfo&, // output
-                                                    Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsConvolution2dSupported(const TensorInfo&, // input
-                                                const TensorInfo&, // output
-                                                const Convolution2dDescriptor&, // descriptor
-                                                const TensorInfo&, // weights
-                                                const Optional<TensorInfo>&, // biases
-                                                Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsConvolution3dSupported(const TensorInfo&, // input
-                                                const TensorInfo&, // output
-                                                const Convolution3dDescriptor&, // descriptor
-                                                const TensorInfo&, // weights
-                                                const Optional<TensorInfo>&, // biases
-                                                Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsDebugSupported(const TensorInfo&, // input
-                                        const TensorInfo&, // output
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsDepthToSpaceSupported(const TensorInfo&, // input
-                                               const TensorInfo&, // output
-                                               const DepthToSpaceDescriptor&, // descriptor
-                                               Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsDepthwiseConvolutionSupported(const TensorInfo&, //input
-                                                       const TensorInfo&, //output
-                                                       const DepthwiseConvolution2dDescriptor&, // descriptor
-                                                       const TensorInfo&, // weights
-                                                       const Optional<TensorInfo>&, // biases
-                                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsDequantizeSupported(const TensorInfo&, // input
-                                             const TensorInfo&, // output
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
 bool LayerSupportBase::IsDetectionPostProcessSupported(const TensorInfo&, // boxEncodings
                                                        const TensorInfo&, // scores
                                                        const TensorInfo&, // anchors
@@ -243,150 +95,6 @@ bool LayerSupportBase::IsDetectionPostProcessSupported(const TensorInfo&, // box
     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
-bool LayerSupportBase::IsDilatedDepthwiseConvolutionSupported(const TensorInfo&, // input
-                                                              const TensorInfo&, // output
-                                                              const DepthwiseConvolution2dDescriptor&, // descriptor
-                                                              const TensorInfo&,// weights
-                                                              const Optional<TensorInfo>&, // biases
-                                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsDivisionSupported(const TensorInfo&, // input0
-                                           const TensorInfo&, // input1
-                                           const TensorInfo&, // output
-                                           Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsElementwiseUnarySupported(const TensorInfo&, // input
-                                                   const TensorInfo&, // output
-                                                   const ElementwiseUnaryDescriptor&, // descriptor
-                                                   Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsFakeQuantizationSupported(const TensorInfo&, // input
-                                                   const FakeQuantizationDescriptor&, // descriptor
-                                                   Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsFillSupported(const TensorInfo&, // input
-                                       const TensorInfo&, // output
-                                       const FillDescriptor&, // descriptor
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsFloorSupported(const TensorInfo&, // input
-                                        const TensorInfo&, // output
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsFullyConnectedSupported(const TensorInfo&, // input
-                                                 const TensorInfo&, // output
-                                                 const TensorInfo&, // weights
-                                                 const TensorInfo&, // biases
-                                                 const FullyConnectedDescriptor&, // descriptor
-                                                 Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsGatherSupported(const armnn::TensorInfo&, // input0
-                                         const armnn::TensorInfo&, // input1
-                                         const armnn::TensorInfo&, // output
-                                         const GatherDescriptor&, // descriptor
-                                         armnn::Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsInputSupported(const TensorInfo&, // input
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsInstanceNormalizationSupported(const TensorInfo&, // input
-                                                        const TensorInfo&, // output
-                                                        const InstanceNormalizationDescriptor&, // descriptor
-                                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsL2NormalizationSupported(const TensorInfo&, // input
-                                                  const TensorInfo&, // output
-                                                  const L2NormalizationDescriptor&, // descriptor
-                                                  Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsLogicalBinarySupported(const TensorInfo&, // input0
-                                                const TensorInfo&, // input1
-                                                const TensorInfo&, // output
-                                                const LogicalBinaryDescriptor&, // descriptor
-                                                Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsLogicalUnarySupported(const TensorInfo&, // input
-                                               const TensorInfo&, // output
-                                               const ElementwiseUnaryDescriptor&, // descriptor
-                                               Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsLogSoftmaxSupported(const TensorInfo&, // input
-                                             const TensorInfo&, // output
-                                             const LogSoftmaxDescriptor&, // descriptor
-                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsLstmSupported(const TensorInfo&, // input
-                                       const TensorInfo&, // outputStateIn
-                                       const TensorInfo&, // cellStateIn
-                                       const TensorInfo&, // scratchBuffer
-                                       const TensorInfo&, // outputStateOut
-                                       const TensorInfo&, // cellStateOut
-                                       const TensorInfo&, // output
-                                       const LstmDescriptor&, // descriptor
-                                       const LstmInputParamsInfo&, // paramsInfo
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsMaximumSupported(const TensorInfo&, // input0
-                                          const TensorInfo&, // input1
-                                          const TensorInfo&, // output
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsMeanSupported(const TensorInfo&, // input
-                                       const TensorInfo&, // output
-                                       const MeanDescriptor&, // descriptor
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
 bool LayerSupportBase::IsMemCopySupported(const armnn::TensorInfo&, // input
                                           const armnn::TensorInfo&, // output
                                           armnn::Optional<std::string &> ) const // reasonIfUnsupported
@@ -409,103 +117,6 @@ bool LayerSupportBase::IsMergeSupported(const TensorInfo&, // input0
     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
-bool LayerSupportBase::IsMinimumSupported(const TensorInfo&, // input0
-                                          const TensorInfo&, // input1
-                                          const TensorInfo&, // output
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsMultiplicationSupported(const TensorInfo&, // input0
-                                                 const TensorInfo&, // input1
-                                                 const TensorInfo&, // output
-                                                 Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsNormalizationSupported(const TensorInfo&, // input
-                                                const TensorInfo&, // output
-                                                const NormalizationDescriptor&, // descriptor
-                                                Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsOutputSupported(const TensorInfo&, // output
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsPadSupported(const TensorInfo&, // input
-                                      const TensorInfo&, // output
-                                      const PadDescriptor&, // descriptor
-                                      Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsPermuteSupported(const TensorInfo&, // input
-                                          const TensorInfo&, // output
-                                          const PermuteDescriptor&, // descriptor
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsPooling2dSupported(const TensorInfo&, // input
-                                            const TensorInfo&, // output
-                                            const Pooling2dDescriptor&, // descriptor
-                                            Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsPooling3dSupported(const TensorInfo&, // input
-                                            const TensorInfo&, // output
-                                            const Pooling3dDescriptor&, // descriptor
-                                            Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsPreCompiledSupported(const TensorInfo&, // input
-                                              const PreCompiledDescriptor&, // descriptor
-                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsPreluSupported(const TensorInfo&, // input
-                                        const TensorInfo&, // alpha
-                                        const TensorInfo&, // output
-                                        Optional<std::string &> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsQuantizeSupported(const armnn::TensorInfo&, // input
-                                           const armnn::TensorInfo&, // output
-                                           armnn::Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsQLstmSupported(const TensorInfo&, // input
-                                        const TensorInfo&, // previousOutputIn
-                                        const TensorInfo&, // previousCellStateIn
-                                        const TensorInfo&, // outputStateOut
-                                        const TensorInfo&, // cellStateOut
-                                        const TensorInfo&, // output
-                                        const QLstmDescriptor&, // descriptor
-                                        const LstmInputParamsInfo&, // paramsInfo
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
 bool LayerSupportBase::IsQuantizedLstmSupported(const TensorInfo&, // input
                                                 const TensorInfo&, // previousCellStateIn
                                                 const TensorInfo&, // previousOutputIn
@@ -517,37 +128,6 @@ bool LayerSupportBase::IsQuantizedLstmSupported(const TensorInfo&, // input
     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
-bool LayerSupportBase::IsRankSupported(const TensorInfo&, // input
-                                       const TensorInfo&,  // output
-                                       Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsReduceSupported(const TensorInfo& /*input*/,
-                                         const TensorInfo& /*output*/,
-                                         const ReduceDescriptor& /*descriptor*/,
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsReshapeSupported(const TensorInfo&, // input
-                                          const TensorInfo&, // output
-                                          const ReshapeDescriptor&, // descriptor
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsResizeSupported(const TensorInfo&, // input
-                                         const TensorInfo&, // output
-                                         const ResizeDescriptor&, // descriptor
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
 bool LayerSupportBase::IsShapeSupported(const TensorInfo&, // input
                                         const TensorInfo&, // output
                                         Optional<std::string&> reasonIfUnsupported) const
@@ -555,54 +135,6 @@ bool LayerSupportBase::IsShapeSupported(const TensorInfo&, // input
     return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
 }
 
-bool LayerSupportBase::IsSliceSupported(const TensorInfo&, // input
-                                        const TensorInfo&, // output
-                                        const SliceDescriptor&, // descriptor
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsSoftmaxSupported(const TensorInfo&, // input
-                                          const TensorInfo&, // output
-                                          const SoftmaxDescriptor&, // descriptor
-                                          Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-/**/
-bool LayerSupportBase::IsSpaceToBatchNdSupported(const TensorInfo&, // input
-                                                 const TensorInfo&, // output
-                                                 const SpaceToBatchNdDescriptor&, // descriptor
-                                                 Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsSpaceToDepthSupported(const TensorInfo&, // input
-                                               const TensorInfo&, // output
-                                               const SpaceToDepthDescriptor&, // descriptor
-                                               Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsSplitterSupported(const TensorInfo&, // input
-                                           const std::vector<std::reference_wrapper<TensorInfo>>&, // outputs
-                                           const ViewsDescriptor&, // descriptor
-                                           Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsStackSupported(const std::vector<const TensorInfo*>&, // inputs
-                                        const TensorInfo&, // output
-                                        const StackDescriptor&, // descriptor
-                                        Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
 bool LayerSupportBase::IsStandInSupported(const std::vector<const TensorInfo*>&, // inputs
                                           const std::vector<const TensorInfo*>&, // outputs
                                           const StandInDescriptor&, // descriptor
@@ -619,60 +151,4 @@ bool LayerSupportBase::IsStandInSupported(const std::vector<const TensorInfo*>&,
     return false;
 }
 
-bool LayerSupportBase::IsStridedSliceSupported(const TensorInfo&, // input
-                                               const TensorInfo&, // output
-                                               const StridedSliceDescriptor&, // descriptor
-                                               Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsSubtractionSupported(const TensorInfo&, // input0
-                                              const TensorInfo&, // input1
-                                              const TensorInfo&, // output
-                                              Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsSwitchSupported(const TensorInfo&, // input0
-                                         const TensorInfo&, // input1
-                                         const TensorInfo&, // output0
-                                         const TensorInfo&, // output1
-                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsTransposeConvolution2dSupported(const TensorInfo&, // input
-                                                         const TensorInfo&, // output
-                                                         const TransposeConvolution2dDescriptor&, // descriptor
-                                                         const TensorInfo&, // weights
-                                                         const Optional<TensorInfo>&, // biases
-                                                         Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-} 
-
-bool LayerSupportBase::IsTransposeSupported(const TensorInfo&, // input 
-                                            const TensorInfo&, // output
-                                            const TransposeDescriptor&, // descriptor
-                                            Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
-bool LayerSupportBase::IsUnidirectionalSequenceLstmSupported(const TensorInfo&, // input
-                                                             const TensorInfo&, // outputStateIn
-                                                             const TensorInfo&, // cellStateIn
-                                                             const TensorInfo&, // outputStateOut
-                                                             const TensorInfo&, // cellStateOut
-                                                             const TensorInfo&, // output
-                                                             const LstmDescriptor&, // descriptor
-                                                             const LstmInputParamsInfo&, // paramsInfo
-                                                             Optional<std::string&> reasonIfUnsupported) const
-{
-    return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
-}
-
 } // namespace armnn
diff --git a/src/backends/backendsCommon/LayerSupportBase.hpp b/src/backends/backendsCommon/LayerSupportBase.hpp
index acf24a2d3a..9dea90e071 100644
--- a/src/backends/backendsCommon/LayerSupportBase.hpp
+++ b/src/backends/backendsCommon/LayerSupportBase.hpp
@@ -21,119 +21,6 @@ public:
                           const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo = EmptyOptional(),
                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsActivationSupported(const TensorInfo& input,
-                               const TensorInfo& output,
-                               const ActivationDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsAdditionSupported(const TensorInfo& input0,
-                             const TensorInfo& input1,
-                             const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsArgMinMaxSupported(const TensorInfo& input,
-                              const TensorInfo& output,
-                              const ArgMinMaxDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsBatchNormalizationSupported(const TensorInfo& input,
-                                       const TensorInfo& output,
-                                       const TensorInfo& mean,
-                                       const TensorInfo& var,
-                                       const TensorInfo& beta,
-                                       const TensorInfo& gamma,
-                                       const BatchNormalizationDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsBatchToSpaceNdSupported(const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const BatchToSpaceNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsCastSupported(const TensorInfo& input,
-                         const TensorInfo& output,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsChannelShuffleSupported(const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const ChannelShuffleDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsComparisonSupported(const TensorInfo& input0,
-                               const TensorInfo& input1,
-                               const TensorInfo& output,
-                               const ComparisonDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
-                           const TensorInfo& output,
-                           const OriginsDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsConstantSupported(const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsConvertFp16ToFp32Supported(const TensorInfo& input,
-                                      const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsConvertFp32ToFp16Supported(
-            const TensorInfo& input,
-            const TensorInfo& output,
-            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsConvolution2dSupported(const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  const Convolution2dDescriptor& descriptor,
-                                  const TensorInfo& weights,
-                                  const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsConvolution3dSupported(const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  const Convolution3dDescriptor& descriptor,
-                                  const TensorInfo& weights,
-                                  const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsDebugSupported(const TensorInfo& input,
-                          const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsDepthToSpaceSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 const DepthToSpaceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsDepthwiseConvolutionSupported(const TensorInfo& input,
-                                         const TensorInfo& output,
-                                         const DepthwiseConvolution2dDescriptor& descriptor,
-                                         const TensorInfo& weights,
-                                         const Optional<TensorInfo>& biases,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsDequantizeSupported(const TensorInfo& input,
-                               const TensorInfo& output,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
     bool IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
                                          const TensorInfo& scores,
                                          const TensorInfo& anchors,
@@ -142,205 +29,20 @@ public:
                                          const TensorInfo& detectionScores,
                                          const TensorInfo& numDetections,
                                          const DetectionPostProcessDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
-                                                const TensorInfo& output,
-                                                const DepthwiseConvolution2dDescriptor& descriptor,
-                                                const TensorInfo& weights,
-                                                const Optional<TensorInfo>& biases,
-                                                Optional<std::string&> reasonIfUnsupported =
-                                                    EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsDivisionSupported(const TensorInfo& input0,
-                             const TensorInfo& input1,
-                             const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsElementwiseUnarySupported(const TensorInfo& input,
-                                     const TensorInfo& output,
-                                     const ElementwiseUnaryDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsFakeQuantizationSupported(const TensorInfo& input,
-                                     const FakeQuantizationDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    virtual bool IsFillSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 const FillDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsFloorSupported(const TensorInfo& input,
-                          const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsFullyConnectedSupported(const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const TensorInfo& weights,
-                                   const TensorInfo& biases,
-                                   const FullyConnectedDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsGatherSupported(const TensorInfo& input0,
-                           const TensorInfo& input1,
-                           const TensorInfo& output,
-                           const GatherDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsInputSupported(const TensorInfo& input,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsInstanceNormalizationSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const InstanceNormalizationDescriptor& descriptor,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsL2NormalizationSupported(const TensorInfo& input,
-                                    const TensorInfo& output,
-                                    const L2NormalizationDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsLogicalBinarySupported(const TensorInfo& input0,
-                                  const TensorInfo& input1,
-                                  const TensorInfo& output,
-                                  const LogicalBinaryDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsLogicalUnarySupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 const ElementwiseUnaryDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsLogSoftmaxSupported(const TensorInfo& input,
-                               const TensorInfo& output,
-                               const LogSoftmaxDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsLstmSupported(const TensorInfo& input,
-                         const TensorInfo& outputStateIn,
-                         const TensorInfo& cellStateIn,
-                         const TensorInfo& scratchBuffer,
-                         const TensorInfo& outputStateOut,
-                         const TensorInfo& cellStateOut,
-                         const TensorInfo& output,
-                         const LstmDescriptor& descriptor,
-                         const LstmInputParamsInfo& paramsInfo,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsMaximumSupported(const TensorInfo& input0,
-                            const TensorInfo& input1,
-                            const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsMeanSupported(const TensorInfo& input,
-                         const TensorInfo& output,
-                         const MeanDescriptor& descriptor,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMemCopySupported(const TensorInfo& input,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMemImportSupported(const TensorInfo& input,
                               const TensorInfo& output,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMergeSupported(const TensorInfo& input0,
                           const TensorInfo& input1,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsMinimumSupported(const TensorInfo& input0,
-                            const TensorInfo& input1,
-                            const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsMultiplicationSupported(const TensorInfo& input0,
-                                   const TensorInfo& input1,
-                                   const TensorInfo& output,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsNormalizationSupported(const TensorInfo& input,
-                                  const TensorInfo& output,
-                                  const NormalizationDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsOutputSupported(const TensorInfo& output,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsPadSupported(const TensorInfo& input,
-                        const TensorInfo& output,
-                        const PadDescriptor& descriptor,
-                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsPermuteSupported(const TensorInfo& input,
-                            const TensorInfo& output,
-                            const PermuteDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsPooling2dSupported(const TensorInfo& input,
-                              const TensorInfo& output,
-                              const Pooling2dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsPooling3dSupported(const TensorInfo& input,
-                              const TensorInfo& output,
-                              const Pooling3dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsPreCompiledSupported(const TensorInfo& input,
-                                const PreCompiledDescriptor& descriptor,
-                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsPreluSupported(const TensorInfo& input,
-                          const TensorInfo& alpha,
-                          const TensorInfo& output,
-                          Optional<std::string &> reasonIfUnsupported) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsQuantizeSupported(const TensorInfo& input,
-                             const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsQLstmSupported(const TensorInfo& input,
-                          const TensorInfo& previousOutputIn,
-                          const TensorInfo& previousCellStateIn,
-                          const TensorInfo& outputStateOut,
-                          const TensorInfo& cellStateOut,
-                          const TensorInfo& output,
-                          const QLstmDescriptor& descriptor,
-                          const LstmInputParamsInfo& paramsInfo,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQuantizedLstmSupported(const TensorInfo& input,
                                   const TensorInfo& previousCellStateIn,
@@ -348,121 +50,16 @@ public:
                                   const TensorInfo& cellStateOut,
                                   const TensorInfo& output,
                                   const QuantizedLstmInputParamsInfo& paramsInfo,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsRankSupported(const TensorInfo& input,
-                         const TensorInfo& output,
-                         Optional<std::string&> reasonIfUnsupported) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsReduceSupported(const TensorInfo& input,
-                           const TensorInfo& output,
-                           const ReduceDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsReshapeSupported(const TensorInfo& input,
-                            const TensorInfo& output,
-                            const ReshapeDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsResizeSupported(const TensorInfo& input,
-                           const TensorInfo& output,
-                           const ResizeDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsShapeSupported(const TensorInfo& input,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsSliceSupported(const TensorInfo& input,
-                          const TensorInfo& output,
-                          const SliceDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsSoftmaxSupported(const TensorInfo& input,
-                            const TensorInfo& output,
-                            const SoftmaxDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsSpaceToBatchNdSupported(const TensorInfo& input,
-                                   const TensorInfo& output,
-                                   const SpaceToBatchNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsSpaceToDepthSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 const SpaceToDepthDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsSplitterSupported(const TensorInfo& input,
-                             const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
-                             const ViewsDescriptor& descriptor,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,
-                          const TensorInfo& output,
-                          const StackDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsStandInSupported(const std::vector<const TensorInfo*>& inputs,
                             const std::vector<const TensorInfo*>& outputs,
                             const StandInDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsStridedSliceSupported(const TensorInfo& input,
-                                 const TensorInfo& output,
-                                 const StridedSliceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsSubtractionSupported(const TensorInfo& input0,
-                                const TensorInfo& input1,
-                                const TensorInfo& output,
-                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsSwitchSupported(const TensorInfo& input0,
-                           const TensorInfo& input1,
-                           const TensorInfo& output0,
-                           const TensorInfo& output1,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsTransposeConvolution2dSupported(
-        const TensorInfo& input,
-        const TensorInfo& output,
-        const TransposeConvolution2dDescriptor& descriptor,
-        const TensorInfo& weights,
-        const Optional<TensorInfo>& biases,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsTransposeSupported(const TensorInfo& input,
-                              const TensorInfo& output,
-                              const TransposeDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
-
-    ARMNN_DEPRECATED_MSG_REMOVAL_DATE("This method is deprecated. Use IsLayerSupported instead.", "23.08")
-    bool IsUnidirectionalSequenceLstmSupported(
-        const TensorInfo& input,
-        const TensorInfo& outputStateIn,
-        const TensorInfo& cellStateIn,
-        const TensorInfo& outputStateOut,
-        const TensorInfo& cellStateOut,
-        const TensorInfo& output,
-        const LstmDescriptor& descriptor,
-        const LstmInputParamsInfo& paramsInfo,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
 };
 
diff --git a/src/backends/backendsCommon/test/mockBackend/MockImportLayerSupport.hpp b/src/backends/backendsCommon/test/mockBackend/MockImportLayerSupport.hpp
index da4b7ab7d0..083632cfd2 100644
--- a/src/backends/backendsCommon/test/mockBackend/MockImportLayerSupport.hpp
+++ b/src/backends/backendsCommon/test/mockBackend/MockImportLayerSupport.hpp
@@ -46,7 +46,7 @@ public:
     bool IsAdditionSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const
     {
         IgnoreUnused(input0);
         IgnoreUnused(input1);
@@ -56,7 +56,7 @@ public:
     }
 
     bool IsInputSupported(const TensorInfo& input,
-                          Optional<std::string&> reasonIfUnsupported) const override
+                          Optional<std::string&> reasonIfUnsupported) const
     {
         IgnoreUnused(input);
         IgnoreUnused(reasonIfUnsupported);
@@ -64,7 +64,7 @@ public:
     }
 
     bool IsOutputSupported(const TensorInfo& output,
-                           Optional<std::string&> reasonIfUnsupported) const override
+                           Optional<std::string&> reasonIfUnsupported) const
     {
         IgnoreUnused(output);
         IgnoreUnused(reasonIfUnsupported);
diff --git a/src/backends/cl/ClLayerSupport.hpp b/src/backends/cl/ClLayerSupport.hpp
index 2b3593630a..737ab7a850 100644
--- a/src/backends/cl/ClLayerSupport.hpp
+++ b/src/backends/cl/ClLayerSupport.hpp
@@ -23,23 +23,23 @@ public:
                           const BaseDescriptor& descriptor,
                           const Optional<LstmInputParamsInfo>& lstmParamsInfo,
                           const Optional<QuantizedLstmInputParamsInfo>& quantizedLstmParamsInfo,
-                          Optional<std::string&> reasonIfUnsupported) const override;
+                          Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsActivationSupported(const TensorInfo& input,
                                const TensorInfo& output,
                                const ActivationDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")
     bool IsAdditionSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsArgMinMaxSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const ArgMinMaxDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsBatchMatMulSupported(const TensorInfo& inputX,
                                 const TensorInfo& inputY,
@@ -54,107 +54,107 @@ public:
                                        const TensorInfo& beta,
                                        const TensorInfo& gamma,
                                        const BatchNormalizationDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsBatchToSpaceNdSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const BatchToSpaceNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsCastSupported(const TensorInfo& input,
                          const TensorInfo& output,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsChannelShuffleSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const ChannelShuffleDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsComparisonSupported(const TensorInfo& input0,
                                const TensorInfo& input1,
                                const TensorInfo& ouput,
                                const ComparisonDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                            const TensorInfo& output,
                            const OriginsDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConstantSupported(const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvertFp16ToFp32Supported(const TensorInfo& input,
                                       const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvertFp32ToFp16Supported(const TensorInfo& input,
                                       const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvolution2dSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const Convolution2dDescriptor& descriptor,
                                   const TensorInfo& weights,
                                   const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvolution3dSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const Convolution3dDescriptor& descriptor,
                                   const TensorInfo& weights,
                                   const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDequantizeSupported(const TensorInfo& input,
                                const TensorInfo& output,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDepthToSpaceSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const DepthToSpaceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDepthwiseConvolutionSupported(const TensorInfo& input,
                                          const TensorInfo& output,
                                          const DepthwiseConvolution2dDescriptor& descriptor,
                                          const TensorInfo& weights,
                                          const Optional<TensorInfo>& biases,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
                                                 const TensorInfo& output,
                                                 const DepthwiseConvolution2dDescriptor& descriptor,
                                                 const TensorInfo& weights,
                                                 const Optional<TensorInfo>& biases,
-                                                Optional<std::string&> reason = EmptyOptional()) const override;
+                                                Optional<std::string&> reason = EmptyOptional()) const;
 
     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")
     bool IsDivisionSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsElementwiseUnarySupported(const TensorInfo& input,
                                      const TensorInfo& output,
                                      const ElementwiseUnaryDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFillSupported(const TensorInfo& input,
                          const TensorInfo& output,
                          const FillDescriptor& descriptor,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFloorSupported(const TensorInfo& input,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFullyConnectedSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const TensorInfo& weights,
                                    const TensorInfo& biases,
                                    const FullyConnectedDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsGatherNdSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
@@ -165,31 +165,31 @@ public:
                            const TensorInfo& input1,
                            const TensorInfo& output,
                            const GatherDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported) const override;
+                           Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsInputSupported(const TensorInfo& input,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsInstanceNormalizationSupported(const TensorInfo& input,
                                           const TensorInfo& output,
                                           const InstanceNormalizationDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsL2NormalizationSupported(const TensorInfo& input,
                                     const TensorInfo& output,
                                     const L2NormalizationDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsLogicalBinarySupported(const TensorInfo& input0,
                                   const TensorInfo& input1,
                                   const TensorInfo& output,
                                   const LogicalBinaryDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported) const override;
+                                  Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsLogSoftmaxSupported(const TensorInfo& input,
                                const TensorInfo& output,
                                const LogSoftmaxDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsLstmSupported(const TensorInfo& input,
                          const TensorInfo& outputStateIn,
@@ -200,63 +200,63 @@ public:
                          const TensorInfo& output,
                          const LstmDescriptor& descriptor,
                          const LstmInputParamsInfo& paramsInfo,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")
     bool IsMaximumSupported(const TensorInfo& input0,
                             const TensorInfo& input1,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMeanSupported(const TensorInfo& input,
                          const TensorInfo& output,
                          const MeanDescriptor& descriptor,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")
     bool IsMinimumSupported(const TensorInfo& input0,
                             const TensorInfo& input1,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")
     bool IsMultiplicationSupported(const TensorInfo& input0,
                                    const TensorInfo& input1,
                                    const TensorInfo& output,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsNormalizationSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const NormalizationDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsOutputSupported(const TensorInfo& output,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPadSupported(const TensorInfo& input,
                         const TensorInfo& output,
                         const PadDescriptor& descriptor,
-                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPermuteSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const PermuteDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPooling2dSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const Pooling2dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPooling3dSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const Pooling3dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPreluSupported(const TensorInfo& input,
                           const TensorInfo& alpha,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQLstmSupported(const TensorInfo& input,
                           const TensorInfo& previousOutputIn,
@@ -266,7 +266,7 @@ public:
                           const TensorInfo& output,
                           const QLstmDescriptor& descriptor,
                           const LstmInputParamsInfo& paramsInfo,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQuantizedLstmSupported(const TensorInfo& input,
                                   const TensorInfo& previousCellStateIn,
@@ -274,79 +274,79 @@ public:
                                   const TensorInfo& cellStateOut,
                                   const TensorInfo& output,
                                   const QuantizedLstmInputParamsInfo& paramsInfo,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQuantizeSupported(const TensorInfo& input,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsReduceSupported(const TensorInfo& input,
                            const TensorInfo& output,
                            const ReduceDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsReshapeSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const ReshapeDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsResizeSupported(const TensorInfo& input,
                            const TensorInfo& output,
                            const ResizeDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSliceSupported(const TensorInfo& input,
                           const TensorInfo& output,
                           const SliceDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSoftmaxSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const SoftmaxDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSpaceToBatchNdSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const SpaceToBatchNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSpaceToDepthSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const SpaceToDepthDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSplitterSupported(const TensorInfo& input,
                              const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
                              const ViewsDescriptor& descriptor,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,
                           const TensorInfo& output,
                           const StackDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsStridedSliceSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const StridedSliceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use IsLayerSupported instead", "24.02")
     bool IsSubtractionSupported(const TensorInfo& input0,
                                 const TensorInfo& input1,
                                 const TensorInfo& output,
-                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsTransposeConvolution2dSupported(const TensorInfo& input,
                                            const TensorInfo& output,
                                            const TransposeConvolution2dDescriptor& descriptor,
                                            const TensorInfo& weights,
                                            const Optional<TensorInfo>& biases,
-                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsTransposeSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const TransposeDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsUnidirectionalSequenceLstmSupported(const TensorInfo& input,
                                                const TensorInfo& outputStateIn,
@@ -356,7 +356,7 @@ public:
                                                const TensorInfo& output,
                                                const UnidirectionalSequenceLstmDescriptor& descriptor,
                                                const LstmInputParamsInfo& paramsInfo,
-                                               Optional<std::string&> reasonIfUnsupported) const override;
+                                               Optional<std::string&> reasonIfUnsupported) const;
 
 private:
     const IBackendInternal::IBackendSpecificModelContextPtr m_ModelContextPtr;
diff --git a/src/backends/neon/NeonLayerSupport.hpp b/src/backends/neon/NeonLayerSupport.hpp
index 8a33dce75a..4bc96acd30 100644
--- a/src/backends/neon/NeonLayerSupport.hpp
+++ b/src/backends/neon/NeonLayerSupport.hpp
@@ -29,17 +29,17 @@ public:
     bool IsActivationSupported(const TensorInfo& input,
                                const TensorInfo& output,
                                const ActivationDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsAdditionSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsArgMinMaxSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const ArgMinMaxDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsBatchMatMulSupported(const TensorInfo& inputX,
                                 const TensorInfo& inputY,
@@ -54,62 +54,62 @@ public:
                                        const TensorInfo& beta,
                                        const TensorInfo& gamma,
                                        const BatchNormalizationDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsBatchToSpaceNdSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const BatchToSpaceNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsCastSupported(const TensorInfo& input,
                          const TensorInfo& output,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsChannelShuffleSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const ChannelShuffleDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsComparisonSupported(const TensorInfo& input0,
                                const TensorInfo& input1,
                                const TensorInfo& output,
                                const ComparisonDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                            const TensorInfo& output,
                            const OriginsDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConstantSupported(const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvertFp16ToFp32Supported(const TensorInfo& input,
                                       const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvertFp32ToFp16Supported(const TensorInfo& input,
                                       const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvolution2dSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const Convolution2dDescriptor& descriptor,
                                   const TensorInfo& weights,
                                   const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvolution3dSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const Convolution3dDescriptor& descriptor,
                                   const TensorInfo& weights,
                                   const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDepthToSpaceSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const DepthToSpaceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
 
     bool IsDepthwiseConvolutionSupported(const TensorInfo& input,
@@ -117,39 +117,39 @@ public:
                                          const DepthwiseConvolution2dDescriptor& descriptor,
                                          const TensorInfo& weights,
                                          const Optional<TensorInfo>& biases,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDequantizeSupported(const TensorInfo& input,
                                const TensorInfo& output,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
                                                 const TensorInfo& output,
                                                 const DepthwiseConvolution2dDescriptor& descriptor,
                                                 const TensorInfo& weights,
                                                 const Optional<TensorInfo>& biases,
-                                                Optional<std::string&> reason = EmptyOptional()) const override;
+                                                Optional<std::string&> reason = EmptyOptional()) const;
 
     bool IsElementwiseUnarySupported(const TensorInfo& input,
                                const TensorInfo& output,
                                const ElementwiseUnaryDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFillSupported(const TensorInfo& input,
                          const TensorInfo& output,
                          const FillDescriptor& descriptor,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFloorSupported(const TensorInfo& input,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFullyConnectedSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const TensorInfo& weights,
                                    const TensorInfo& biases,
                                    const FullyConnectedDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsGatherNdSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
@@ -160,31 +160,31 @@ public:
                            const TensorInfo& input1,
                            const TensorInfo& output,
                            const GatherDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported) const override;
+                           Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsInputSupported(const TensorInfo& input,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsInstanceNormalizationSupported(const TensorInfo& input,
                                           const TensorInfo& output,
                                           const InstanceNormalizationDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsL2NormalizationSupported(const TensorInfo& input,
                                     const TensorInfo& output,
                                     const L2NormalizationDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsLogicalBinarySupported(const TensorInfo& input0,
                                   const TensorInfo& input1,
                                   const TensorInfo& output,
                                   const LogicalBinaryDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported) const override;
+                                  Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsLogSoftmaxSupported(const TensorInfo& input,
                                const TensorInfo& output,
                                const LogSoftmaxDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsLstmSupported(const TensorInfo& input,
                          const TensorInfo& outputStateIn,
@@ -195,63 +195,63 @@ public:
                          const TensorInfo& output,
                          const LstmDescriptor& descriptor,
                          const LstmInputParamsInfo& paramsInfo,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMaximumSupported(const TensorInfo& input0,
                             const TensorInfo& input1,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMeanSupported(const TensorInfo& input,
                          const TensorInfo& output,
                          const MeanDescriptor& descriptor,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMinimumSupported(const TensorInfo& input0,
                             const TensorInfo& input1,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMultiplicationSupported(const TensorInfo& input0,
                                    const TensorInfo& input1,
                                    const TensorInfo& output,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDivisionSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsNormalizationSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const NormalizationDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsOutputSupported(const TensorInfo& output,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPadSupported(const TensorInfo& input,
                         const TensorInfo& output,
                         const PadDescriptor& descriptor,
-                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPermuteSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const PermuteDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPooling2dSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const Pooling2dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
     bool IsPooling3dSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const Pooling3dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
     bool IsPreluSupported(const TensorInfo& input,
                           const TensorInfo& alpha,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQLstmSupported(const TensorInfo& input,
                           const TensorInfo& previousOutputIn,
@@ -261,11 +261,11 @@ public:
                           const TensorInfo& output,
                           const QLstmDescriptor& descriptor,
                           const LstmInputParamsInfo& paramsInfo,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQuantizeSupported(const TensorInfo& input,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQuantizedLstmSupported(const TensorInfo& input,
                                   const TensorInfo& cellStateIn,
@@ -273,62 +273,62 @@ public:
                                   const TensorInfo& cellStateOut,
                                   const TensorInfo& outputStateOut,
                                   const QuantizedLstmInputParamsInfo& paramsInfo,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsReduceSupported(const TensorInfo& input,
                            const TensorInfo& output,
                            const ReduceDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsReshapeSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const ReshapeDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsResizeSupported(const TensorInfo& input,
                            const TensorInfo& output,
                            const ResizeDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSliceSupported(const TensorInfo& input,
                           const TensorInfo& output,
                           const SliceDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSoftmaxSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const SoftmaxDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSpaceToBatchNdSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const SpaceToBatchNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSpaceToDepthSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const SpaceToDepthDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSplitterSupported(const TensorInfo& input,
                              const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
                              const ViewsDescriptor& descriptor,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,
                           const TensorInfo& output,
                           const StackDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsStridedSliceSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const StridedSliceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSubtractionSupported(const TensorInfo& input0,
                                 const TensorInfo& input1,
                                 const TensorInfo& output,
-                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsTileSupported(const TensorInfo& input0,
                          const TensorInfo& output,
@@ -340,12 +340,12 @@ public:
                                            const TransposeConvolution2dDescriptor& descriptor,
                                            const TensorInfo& weights,
                                            const Optional<TensorInfo>& biases,
-                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsTransposeSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const TransposeDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsUnidirectionalSequenceLstmSupported(const TensorInfo& input,
                                                const TensorInfo& outputStateIn,
@@ -355,7 +355,7 @@ public:
                                                const TensorInfo& output,
                                                const UnidirectionalSequenceLstmDescriptor& descriptor,
                                                const LstmInputParamsInfo& paramsInfo,
-                                               Optional<std::string&> reasonIfUnsupported) const override;
+                                               Optional<std::string&> reasonIfUnsupported) const;
 
 private:
     const IBackendInternal::IBackendSpecificModelContextPtr m_ModelContextPtr;
diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp
index 42b5814380..377afac62f 100644
--- a/src/backends/reference/RefLayerSupport.hpp
+++ b/src/backends/reference/RefLayerSupport.hpp
@@ -22,17 +22,17 @@ public:
     bool IsActivationSupported(const TensorInfo& input,
                                const TensorInfo& output,
                                const ActivationDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsAdditionSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsArgMinMaxSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const ArgMinMaxDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsBatchMatMulSupported(const TensorInfo& inputX,
                                 const TensorInfo& inputY,
@@ -47,78 +47,78 @@ public:
                                        const TensorInfo& beta,
                                        const TensorInfo& gamma,
                                        const BatchNormalizationDescriptor& descriptor,
-                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                       Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsBatchToSpaceNdSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const BatchToSpaceNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsCastSupported(const TensorInfo& input,
                          const TensorInfo& output,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsChannelShuffleSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const ChannelShuffleDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsComparisonSupported(const TensorInfo& input0,
                                const TensorInfo& input1,
                                const TensorInfo& output,
                                const ComparisonDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
                            const TensorInfo& output,
                            const OriginsDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConstantSupported(const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvertFp16ToFp32Supported(const TensorInfo& input,
                                       const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
 
     bool IsConvertFp32ToFp16Supported(const TensorInfo& input,
                                       const TensorInfo& output,
-                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                      Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvolution2dSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const Convolution2dDescriptor& descriptor,
                                   const TensorInfo& weights,
                                   const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsConvolution3dSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const Convolution3dDescriptor& descriptor,
                                   const TensorInfo& weights,
                                   const Optional<TensorInfo>& biases,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDebugSupported(const TensorInfo& input,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDepthToSpaceSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const DepthToSpaceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDepthwiseConvolutionSupported(const TensorInfo& input,
                                          const TensorInfo& output,
                                          const DepthwiseConvolution2dDescriptor& descriptor,
                                          const TensorInfo& weights,
                                          const Optional<TensorInfo>& biases,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDequantizeSupported(const TensorInfo& input,
                                const TensorInfo& output,
-                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
                                          const TensorInfo& scores,
@@ -128,7 +128,7 @@ public:
                                          const TensorInfo& detectionScores,
                                          const TensorInfo& numDetections,
                                          const DetectionPostProcessDescriptor& descriptor,
-                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
                                                 const TensorInfo& output,
@@ -136,37 +136,37 @@ public:
                                                 const TensorInfo& weights,
                                                 const Optional<TensorInfo>& biases,
                                                 Optional<std::string&> reasonIfUnsupported =
-                                                    EmptyOptional()) const override;
+                                                    EmptyOptional()) const;
 
     bool IsDivisionSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsElementwiseUnarySupported(const TensorInfo& input,
                                      const TensorInfo& output,
                                      const ElementwiseUnaryDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFakeQuantizationSupported(const TensorInfo& input,
                                      const FakeQuantizationDescriptor& descriptor,
-                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                     Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFillSupported(const TensorInfo& input,
                          const TensorInfo& output,
                          const FillDescriptor& descriptor,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFloorSupported(const TensorInfo& input,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsFullyConnectedSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const TensorInfo& weights,
                                    const TensorInfo& biases,
                                    const FullyConnectedDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsGatherNdSupported(const TensorInfo& input0,
                              const TensorInfo& input1,
@@ -177,31 +177,31 @@ public:
                            const TensorInfo& input1,
                            const TensorInfo& output,
                            const GatherDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsInputSupported(const TensorInfo& input,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsInstanceNormalizationSupported(const TensorInfo& input,
                                           const TensorInfo& output,
                                           const InstanceNormalizationDescriptor& descriptor,
-                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsL2NormalizationSupported(const TensorInfo& input,
                                     const TensorInfo& output,
                                     const L2NormalizationDescriptor& descriptor,
-                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                    Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsLogicalBinarySupported(const TensorInfo& input0,
                                   const TensorInfo& input1,
                                   const TensorInfo& output,
                                   const LogicalBinaryDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported) const override;
+                                  Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsLogSoftmaxSupported(const TensorInfo& input,
                                const TensorInfo& output,
                                const LogSoftmaxDescriptor& descriptor,
-                               Optional<std::string&> reasonIfUnsupported) const override;
+                               Optional<std::string&> reasonIfUnsupported) const;
 
     bool IsLstmSupported(const TensorInfo& input,
                          const TensorInfo& outputStateIn,
@@ -212,63 +212,63 @@ public:
                          const TensorInfo& output,
                          const LstmDescriptor& descriptor,
                          const LstmInputParamsInfo& paramsInfo,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMaximumSupported(const TensorInfo& input0,
                             const TensorInfo& input1,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMeanSupported(const TensorInfo& input,
                          const TensorInfo& output,
                          const MeanDescriptor& descriptor,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMemCopySupported(const TensorInfo& input,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMinimumSupported(const TensorInfo& input0,
                             const TensorInfo& input1,
                             const TensorInfo& output,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsMultiplicationSupported(const TensorInfo& input0,
                                    const TensorInfo& input1,
                                    const TensorInfo& output,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsNormalizationSupported(const TensorInfo& input,
                                   const TensorInfo& output,
                                   const NormalizationDescriptor& descriptor,
-                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsOutputSupported(const TensorInfo& output,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPadSupported(const TensorInfo& input,
                         const TensorInfo& output,
                         const PadDescriptor& descriptor,
-                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPermuteSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const PermuteDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPooling2dSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const Pooling2dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPooling3dSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const Pooling3dDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQuantizeSupported(const TensorInfo& input,
                              const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsQLstmSupported(const TensorInfo& input,
                           const TensorInfo& previousOutputIn,
@@ -278,26 +278,26 @@ public:
                           const TensorInfo& output,
                           const QLstmDescriptor& descriptor,
                           const LstmInputParamsInfo& paramsInfo,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsRankSupported(const TensorInfo& input,
                          const TensorInfo& output,
-                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                         Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsReduceSupported(const TensorInfo& input,
                            const TensorInfo& output,
                            const ReduceDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsReshapeSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const ReshapeDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsResizeSupported(const TensorInfo& input,
                            const TensorInfo& output,
                            const ResizeDescriptor& descriptor,
-                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                           Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsReverseV2Supported(const TensorInfo& input0,
                               const TensorInfo& input1,
@@ -306,53 +306,53 @@ public:
 
     bool IsShapeSupported(const TensorInfo& input,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSliceSupported(const TensorInfo& input,
                           const TensorInfo& output,
                           const SliceDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSoftmaxSupported(const TensorInfo& input,
                             const TensorInfo& output,
                             const SoftmaxDescriptor& descriptor,
-                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSpaceToBatchNdSupported(const TensorInfo& input,
                                    const TensorInfo& output,
                                    const SpaceToBatchNdDescriptor& descriptor,
-                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                   Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSpaceToDepthSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const SpaceToDepthDescriptor& descriptor,
                                  Optional<std::string&> reasonIfUnsupported = EmptyOptional())
-                                 const override;
+                                 const;
 
     bool IsSplitterSupported(const TensorInfo& input,
                              const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
                              const ViewsDescriptor& descriptor,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsStackSupported(const std::vector<const TensorInfo*>& inputs,
                           const TensorInfo& output,
                           const StackDescriptor& descriptor,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsStridedSliceSupported(const TensorInfo& input,
                                  const TensorInfo& output,
                                  const StridedSliceDescriptor& descriptor,
-                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                 Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsSubtractionSupported(const TensorInfo& input0,
                                 const TensorInfo& input1,
                                 const TensorInfo& output,
-                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                                Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsPreluSupported(const TensorInfo& input,
                           const TensorInfo& alpha,
                           const TensorInfo& output,
-                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                          Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsTileSupported(const TensorInfo& input,
                          const TensorInfo& output,
@@ -365,12 +365,12 @@ public:
         const TransposeConvolution2dDescriptor& descriptor,
         const TensorInfo& weights,
         const Optional<TensorInfo>& biases,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsTransposeSupported(const TensorInfo& input,
                               const TensorInfo& output,
                               const TransposeDescriptor& descriptor,
-                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+                              Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsUnidirectionalSequenceLstmSupported(
         const TensorInfo& input,
@@ -381,7 +381,7 @@ public:
         const TensorInfo& output,
         const UnidirectionalSequenceLstmDescriptor& descriptor,
         const LstmInputParamsInfo& paramsInfo,
-        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+        Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 };
 
 } // namespace armnn