diff --git a/src/backends/backendsCommon/WorkloadData.cpp b/src/backends/backendsCommon/WorkloadData.cpp
index a26aaf4..bd3c7c2 100644
--- a/src/backends/backendsCommon/WorkloadData.cpp
+++ b/src/backends/backendsCommon/WorkloadData.cpp
@@ -1617,18 +1617,35 @@
 void ReverseV2QueueDescriptor::Validate(const WorkloadInfo &workloadInfo) const {
     const std::string descriptorName{"ReverseV2QueueDescriptor"};
 
-    ValidateNumInputs(workloadInfo,  descriptorName, 1);
+    // Backend restriction
+    const unsigned int maxDimensions = 4;
+
+    ValidateNumInputs(workloadInfo,  descriptorName, 2);
     ValidateNumOutputs(workloadInfo, descriptorName, 1);
 
     const TensorInfo& inputTensorInfo  = workloadInfo.m_InputTensorInfos[0];
+    const TensorInfo& axisTensorInfo  = workloadInfo.m_InputTensorInfos[1];
     const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0];
 
-    auto inputTensorNumDimensions = inputTensorInfo.GetNumDimensions();
-    if (inputTensorNumDimensions > m_Parameters.m_MaxDimension)
+    const auto inputTensorNumDimensions = inputTensorInfo.GetNumDimensions();
+    if (inputTensorNumDimensions > maxDimensions)
     {
         throw InvalidArgumentException(descriptorName +
             ": Input tensors with rank greater than " +
-            std::to_string(m_Parameters.m_MaxDimension) + " are not supported.");
+            std::to_string(maxDimensions) + " are not supported.");
+    }
+
+    const auto axisTensorNumDimensions = axisTensorInfo.GetNumDimensions();
+    if (axisTensorNumDimensions > maxDimensions)
+    {
+        throw InvalidArgumentException(descriptorName +
+            ": More than " + std::to_string(maxDimensions) + " axes cannot be specified.");
+    }
+
+    if (axisTensorNumDimensions > inputTensorNumDimensions)
+    {
+        throw InvalidArgumentException(descriptorName +
+            ": More axes specified than the number of axes on the input tensor.");
     }
 
     std::vector<DataType> supportedTypes =
@@ -1642,44 +1659,18 @@
     };
 
     ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
+
+    std::vector<DataType> axisSupportedTypes =
+    {
+        DataType::Signed32,
+    };
+
+    ValidateDataTypes(axisTensorInfo, axisSupportedTypes, descriptorName);
+
     ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
     ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
-
-    if (m_Parameters.m_Axis.size() > inputTensorNumDimensions)
-    {
-        throw InvalidArgumentException(descriptorName + ": More axes specified than is on the input tensor.");
-    }
-    if (m_Parameters.m_Axis.size() > m_Parameters.m_MaxDimension)
-    {
-        throw InvalidArgumentException(descriptorName +
-            ": More than " + std::to_string(m_Parameters.m_MaxDimension) + " axes cannot be specified.");
-    }
-
-    if (! m_Parameters.m_Axis.empty())
-    {
-        // First check that we have unique axis values
-        auto checkAxis = m_Parameters.m_Axis;
-        std::sort(checkAxis.begin(), checkAxis.end());
-        auto lastUnique = std::unique(checkAxis.begin(), checkAxis.end());
-        if (lastUnique != checkAxis.end())
-        {
-            throw InvalidArgumentException(descriptorName + ": Axes values must be unique.");
-        }
-
-        // Next check that the axes values are in range: [-rank, rank]
-        const auto minmax =
-                std::minmax_element(std::begin(m_Parameters.m_Axis), std::end(m_Parameters.m_Axis));
-        if (((*minmax.first) < int32_t(-inputTensorNumDimensions)) ||
-            ((*minmax.second) >= int32_t (inputTensorNumDimensions)))
-        {
-            throw InvalidArgumentException(descriptorName +
-                ": Axes values must in range [-" + std::to_string(inputTensorNumDimensions) + "," +
-                std::to_string(inputTensorNumDimensions) + "].");
-        }
-    }
 }
 
-
 void FakeQuantizationQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
 {
     const std::string descriptorName{"FakeQuantizationQueueDescriptor"};
diff --git a/src/backends/backendsCommon/WorkloadFactory.cpp b/src/backends/backendsCommon/WorkloadFactory.cpp
index ac4bcc9..ee797b6 100644
--- a/src/backends/backendsCommon/WorkloadFactory.cpp
+++ b/src/backends/backendsCommon/WorkloadFactory.cpp
@@ -1121,12 +1121,12 @@
         }
         case LayerType::ReverseV2:
         {
-            auto cLayer = PolymorphicDowncast<const ReverseV2Layer*>(&layer);
-            const TensorInfo& input  = layer.GetInputSlot(0).GetTensorInfo();
+            const TensorInfo& input0  = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
+            const TensorInfo& input1  = layer.GetInputSlot(1).GetConnection()->GetTensorInfo();
             const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
-            result = layerSupportObject.IsReverseV2Supported(OverrideDataType(input, dataType),
+            result = layerSupportObject.IsReverseV2Supported(OverrideDataType(input0, dataType),
+                                                             OverrideDataType(input1, armnn::DataType::Signed32),
                                                              OverrideDataType(output, dataType),
-                                                             cLayer->GetParameters(),
                                                              reason);
             break;
         }
diff --git a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
index f7a852f..182fab9 100644
--- a/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
+++ b/src/backends/backendsCommon/test/IsLayerSupportedTestImpl.hpp
@@ -744,8 +744,6 @@
 
 DECLARE_LAYER_POLICY_2_PARAM(Reshape)
 
-DECLARE_LAYER_POLICY_2_PARAM(ReverseV2)
-
 DECLARE_LAYER_POLICY_1_PARAM(Shape)
 
 DECLARE_LAYER_POLICY_2_PARAM(Slice)
diff --git a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
index 586b831..3cfd614 100644
--- a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
@@ -23,23 +23,25 @@
         armnn::IWorkloadFactory& workloadFactory,
         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
         const armnn::ITensorHandleFactory& tensorHandleFactory,
-        armnn::ReverseV2Descriptor descriptor,
         const std::vector<T>& input,
+        const std::vector<int>& axis,
         const std::vector<T>& outputExpected,
         const armnn::TensorInfo& inputInfo,
+        const armnn::TensorInfo& axisInfo,
         const armnn::TensorInfo& outputInfo)
     {
         LayerTestResult<T, NumDims> result(outputInfo);
         std::vector<T> outputActual(outputInfo.GetNumElements());
 
         std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo);
+        std::unique_ptr<armnn::ITensorHandle> axisHandle = tensorHandleFactory.CreateTensorHandle(axisInfo);
         std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
 
         armnn::ReverseV2QueueDescriptor queueDescriptor;
-        queueDescriptor.m_Parameters = std::move(descriptor);
         armnn::WorkloadInfo workloadInfo;
 
         AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get());
+        AddInputToWorkload(queueDescriptor, workloadInfo, axisInfo, axisHandle.get());
         AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
 
         // Don't execute if ReverseV2 is not supported, as an exception will be raised.
@@ -47,9 +49,9 @@
         std::string reasonIfUnsupported;
         armnn::LayerSupportHandle handle = armnn::GetILayerSupportByBackendId(backend);
         result.m_Supported = handle.IsReverseV2Supported(inputInfo,
-                                                           outputInfo,
-                                                           queueDescriptor.m_Parameters,
-                                                           reasonIfUnsupported);
+                                                         axisInfo,
+                                                         outputInfo,
+                                                         reasonIfUnsupported);
         if (!result.m_Supported)
         {
             return result;
@@ -58,9 +60,11 @@
         auto workload = workloadFactory.CreateWorkload(armnn::LayerType::ReverseV2, queueDescriptor, workloadInfo);
 
         inputHandle->Allocate();
+        axisHandle->Allocate();
         outputHandle->Allocate();
 
         CopyDataToITensorHandle(inputHandle.get(), input.data());
+        CopyDataToITensorHandle(axisHandle.get(), axis.data());
 
         workload->PostAllocationConfigure();
         ExecuteWorkload(*workload, memoryManager);
@@ -80,13 +84,13 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor. No axes set so output is the same as input
-    auto descriptor = armnn::ReverseV2Descriptor();
+    // Simple test with no axes set so output is the same as input
 
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -94,6 +98,8 @@
         3, 4
     }, qScale, qOffset);
 
+    std::vector<int> axis = armnnUtils::QuantizedVector<int>({}, qScale, qOffset);
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         1, 2,
         3, 4
@@ -102,10 +108,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                                 memoryManager,
                                                 tensorHandleFactory,
-                                                descriptor,
                                                 input,
+                                                axis,
                                                 outputExpected,
                                                 inputInfo,
+                                                axisInfo,
                                                 outputInfo);
 }
 
@@ -115,26 +122,27 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor. Empty tensor set so output is the same as input
-    auto descriptor = armnn::ReverseV2Descriptor();
+    // Simple test with empty input tensor
 
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({0}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({0}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({0}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({}, qScale, qOffset);
-
+    std::vector<int> axis = armnnUtils::QuantizedVector<int>({}, qScale, qOffset);
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({}, qScale, qOffset);
 
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -144,12 +152,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({4}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -157,6 +164,8 @@
         3, 4
     }, qScale, qOffset);
 
+    std::vector<int> axis = {0};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3,
         2, 1
@@ -165,10 +174,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -178,12 +188,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -191,6 +200,8 @@
         3, 4
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         2, 1,
         4, 3
@@ -199,10 +210,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -212,12 +224,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, 0});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2,2}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2,2}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -225,6 +236,8 @@
         3, 4
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1,0};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3,
         2, 1
@@ -233,10 +246,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -246,12 +260,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -263,6 +276,8 @@
         21, 22, 23, 24
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         9, 10, 11, 12,
         5, 6, 7, 8,
@@ -275,10 +290,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -288,12 +304,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -305,6 +320,8 @@
         21, 22, 23, 24
     }, qScale, qOffset);
 
+    std::vector<int> axis = {0, 1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         21, 22, 23, 24,
         17, 18, 19, 20,
@@ -317,10 +334,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -330,14 +348,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, 0, 2});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({3}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 3, 4}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -349,6 +364,8 @@
         21, 22, 23, 24
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1, 0, 2};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         24, 23, 22, 21,
         20, 19, 18, 17,
@@ -361,10 +378,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -374,14 +392,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -395,6 +410,8 @@
         22, 23, 24
     }, qScale, qOffset);
 
+    std::vector<int> axis = {0};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         13, 14, 15,
         16, 17, 18,
@@ -409,10 +426,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -422,14 +440,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -443,6 +458,8 @@
         22, 23, 24
     }, qScale, qOffset);
 
+    std::vector<int> axis = {0, 1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         19, 20, 21,
         22, 23, 24,
@@ -457,10 +474,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -470,14 +488,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1, 2});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({3}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -491,6 +506,8 @@
         22, 23, 24
     }, qScale, qOffset);
 
+    std::vector<int> axis = {0, 1, 2};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         22, 23, 24,
         19, 20, 21,
@@ -505,10 +522,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -518,14 +536,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {0, 1, 2, 3});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({4}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 2, 2, 3}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -539,24 +554,27 @@
         22, 23, 24
     }, qScale, qOffset);
 
+    std::vector<int> axis = {0, 1, 2, 3};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
-                                                                           24, 23, 22,
-                                                                           21, 20, 19,
-                                                                           18, 17, 16,
-                                                                           15, 14, 13,
-                                                                           12, 11, 10,
-                                                                           9, 8, 7,
-                                                                           6, 5, 4,
-                                                                           3, 2, 1
-                                                                   }, qScale, qOffset);
+       24, 23, 22,
+       21, 20, 19,
+       18, 17, 16,
+       15, 14, 13,
+       12, 11, 10,
+       9, 8, 7,
+       6, 5, 4,
+       3, 2, 1
+    }, qScale, qOffset);
 
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -566,13 +584,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor. No axes set so output is the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 3}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -580,6 +596,8 @@
         4, 5, 6
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         3, 2, 1,
         6, 5, 4
@@ -588,10 +606,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -601,14 +620,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 3, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 3, 1}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -616,6 +632,8 @@
         4, 5, 6
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         3, 2, 1,
         6, 5, 4
@@ -624,10 +642,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -637,14 +656,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -652,6 +668,8 @@
         5, 6, 7, 8
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3, 2, 1,
         8, 7, 6, 5
@@ -660,10 +678,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -673,14 +692,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -688,6 +704,8 @@
         5, 6, 7, 8
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3, 2, 1,
         8, 7, 6, 5
@@ -696,10 +714,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -709,14 +728,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({3, 3}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({3, 3}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -725,6 +741,8 @@
         7, 8, 9
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         3, 2, 1,
         6, 5, 4,
@@ -734,10 +752,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -747,14 +766,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({3, 3, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({3, 3, 1}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -763,6 +779,8 @@
         7, 8, 9
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         3, 2, 1,
         6, 5, 4,
@@ -772,10 +790,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -785,14 +804,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({3, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({3, 4}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -801,6 +817,8 @@
         9, 10, 11, 12
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3, 2, 1,
         8, 7, 6, 5,
@@ -810,10 +828,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -823,14 +842,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({3, 4, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({3, 4, 1}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -839,6 +855,8 @@
         9, 10, 11, 12
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3, 2, 1,
         8, 7, 6, 5,
@@ -848,10 +866,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -861,14 +880,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {-1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 4}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({1}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 4}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -876,6 +892,8 @@
         5, 6, 7, 8,
     }, qScale, qOffset);
 
+    std::vector<int> axis = {-1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3, 2, 1,
         8, 7, 6, 5
@@ -884,10 +902,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -897,14 +916,11 @@
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
     const armnn::ITensorHandleFactory& tensorHandleFactory)
 {
-    // Simple test with default descriptor.  No axes set so output is
-    // the same as input
-    auto descriptor = armnn::ReverseV2Descriptor(std::vector<int> {1, -1});
-
     float qScale = 1.0f;
     int32_t qOffset = 0;
 
     armnn::TensorInfo inputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
+    armnn::TensorInfo axisInfo({2}, armnn::DataType::Signed32, qScale, qOffset);
     armnn::TensorInfo outputInfo({2, 4, 1}, ArmnnType, qScale, qOffset);
 
     std::vector<T> input = armnnUtils::QuantizedVector<T>({
@@ -912,6 +928,8 @@
         5, 6, 7, 8,
     }, qScale, qOffset);
 
+    std::vector<int> axis = {1, -1};
+
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         4, 3, 2, 1,
         8, 7, 6, 5
@@ -920,10 +938,11 @@
     return ReverseV2TestImpl<ArmnnType, T, 2>(workloadFactory,
                                               memoryManager,
                                               tensorHandleFactory,
-                                              descriptor,
                                               input,
+                                              axis,
                                               outputExpected,
                                               inputInfo,
+                                              axisInfo,
                                               outputInfo);
 }
 
@@ -1081,4 +1100,4 @@
 ReverseV2SimpleTest2Dim2Axis<armnn::DataType::QSymmS16>(
     armnn::IWorkloadFactory& workloadFactory,
     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
-    const armnn::ITensorHandleFactory& tensorHandleFactory);
\ No newline at end of file
+    const armnn::ITensorHandleFactory& tensorHandleFactory);
diff --git a/src/backends/reference/RefLayerSupport.cpp b/src/backends/reference/RefLayerSupport.cpp
index 1d5fab1..e94478f 100644
--- a/src/backends/reference/RefLayerSupport.cpp
+++ b/src/backends/reference/RefLayerSupport.cpp
@@ -344,7 +344,7 @@
         case LayerType::ReverseV2:
             return IsReverseV2Supported(infos[0],
                                         infos[1],
-                                        *(PolymorphicDowncast<const ReverseV2Descriptor*>(&descriptor)),
+                                        infos[2],
                                         reasonIfUnsupported);
         case LayerType::Reduce:
             return IsReduceSupported(infos[0],
@@ -2361,12 +2361,11 @@
     return supported;
 }
 
-bool RefLayerSupport::IsReverseV2Supported(const TensorInfo& input,
+bool RefLayerSupport::IsReverseV2Supported(const TensorInfo& input0,
+                                           const TensorInfo& input1,
                                            const TensorInfo& output,
-                                           const ReverseV2Descriptor& descriptor,
                                            Optional<std::string&> reasonIfUnsupported) const
 {
-    IgnoreUnused(descriptor);
     bool supported = true;
     // ReverseV2 is data type agnostic so it can support all the types in the Reference backend
     std::array<DataType,6> supportedTypes =
@@ -2379,14 +2378,22 @@
         DataType::QSymmS16
     };
 
-    supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
-                                  "Reference ReverseV2: input type not supported");
+    supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
+                                  "Reference ReverseV2: input0 type not supported");
 
     supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
                                   "Reference ReverseV2: output type not supported");
 
-    supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
-                                  "Reference ReverseV2: input and output types not matching");
+    supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
+                                  "Reference ReverseV2: input0 and output types not matching");
+
+    std::array<DataType,6> input2SupportedTypes =
+    {
+        DataType::Signed32
+    };
+
+    supported &= CheckSupportRule(TypeAnyOf(input1, input2SupportedTypes), reasonIfUnsupported,
+                                  "Reference ReverseV2: input1 type not supported");
 
     return supported;
 }
diff --git a/src/backends/reference/RefLayerSupport.hpp b/src/backends/reference/RefLayerSupport.hpp
index 0afb9c2..21d59e2 100644
--- a/src/backends/reference/RefLayerSupport.hpp
+++ b/src/backends/reference/RefLayerSupport.hpp
@@ -299,9 +299,9 @@
                            const ResizeDescriptor& descriptor,
                            Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
 
-    bool IsReverseV2Supported(const TensorInfo& input,
+    bool IsReverseV2Supported(const TensorInfo& input0,
+                              const TensorInfo& input1,
                               const TensorInfo& output,
-                              const ReverseV2Descriptor& descriptor,
                               Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const;
 
     bool IsShapeSupported(const TensorInfo& input,
diff --git a/src/backends/reference/workloads/RefReverseV2Workload.cpp b/src/backends/reference/workloads/RefReverseV2Workload.cpp
index cd2d9f9..22d5449 100644
--- a/src/backends/reference/workloads/RefReverseV2Workload.cpp
+++ b/src/backends/reference/workloads/RefReverseV2Workload.cpp
@@ -32,16 +32,21 @@
         ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefReverseV2Workload_Execute");
 
         const TensorInfo& inputInfo = GetTensorInfo(inputs[0]);
+        const TensorInfo& axisInfo = GetTensorInfo(inputs[1]);
 
         std::unique_ptr<Decoder<float>> inputDecoder = MakeDecoder<float>(GetTensorInfo(inputs[0]),
                                                                           inputs[0]->Map());
 
+        std::unique_ptr<Decoder<int>> axisDecoder = MakeDecoder<int>(GetTensorInfo(inputs[1]),
+                                                                          inputs[1]->Map());
+
         std::unique_ptr<Encoder<float>> outputEncoder = MakeEncoder<float>(GetTensorInfo(outputs[0]),
                                                                            outputs[0]->Map());
 
-        ReverseV2(m_Data.m_Parameters,
-                  inputInfo,
+        ReverseV2(inputInfo,
+                  axisInfo,
                   *inputDecoder,
+                  *axisDecoder,
                   *outputEncoder);
     }
 
diff --git a/src/backends/reference/workloads/ReverseV2Impl.cpp b/src/backends/reference/workloads/ReverseV2Impl.cpp
index f6d5fd7..896f905 100644
--- a/src/backends/reference/workloads/ReverseV2Impl.cpp
+++ b/src/backends/reference/workloads/ReverseV2Impl.cpp
@@ -75,13 +75,16 @@
     return outputIdx;
 }
 
-void ReverseV2(const ReverseV2Descriptor& params,
-               const TensorInfo& inputInfo,
+void ReverseV2(const TensorInfo& inputInfo,
+               const TensorInfo& axisInfo,
                Decoder<float>& inputDecoder,
+               Decoder<int>& axisDecoder,
                Encoder<float>& outputEncoder)
 {
+    unsigned int axesRank = static_cast<unsigned int>(axisInfo.GetNumElements());
+
     // Empty axis and empty tensor case: copy input to output
-    if (params.m_Axis.empty() || inputInfo.GetNumElements() == 0)
+    if ((axesRank == 0) || inputInfo.GetNumElements() == 0)
     {
         for (unsigned idx = 0; idx < inputInfo.GetNumElements(); idx++)
         {
@@ -95,11 +98,19 @@
 
     unsigned int inputRank = static_cast<unsigned int>(inputInfo.GetNumDimensions());
 
-    std::vector<bool>axisFlag(inputRank, false);
-    std::vector<unsigned int>dimSize(inputRank, 0);
+    std::vector<bool> axisFlag(inputRank, false);
+    std::vector<unsigned int> dimSize(inputRank, 0);
+    std::vector<int32_t> axis(axesRank, 0);
+
+    // Decode the axis information
+    for (unsigned int i=0; i < axesRank; i++)
+    {
+        axis[i] = axisDecoder.Get();
+        axisDecoder += 1;
+    }
 
     // Make sure the axes are positive
-    for (int32_t axisElement: params.m_Axis)
+    for (int32_t axisElement: axis)
     {
         axisElement = axisElement < 0 ? axisElement + static_cast<int32_t>(inputRank) : axisElement;
         axisFlag[static_cast<uint32_t>(axisElement)] = true;
diff --git a/src/backends/reference/workloads/ReverseV2Impl.hpp b/src/backends/reference/workloads/ReverseV2Impl.hpp
index bc1fe1d..59407d4 100644
--- a/src/backends/reference/workloads/ReverseV2Impl.hpp
+++ b/src/backends/reference/workloads/ReverseV2Impl.hpp
@@ -13,9 +13,10 @@
 namespace armnn
 {
 
-void ReverseV2(const ReverseV2Descriptor& params,
-               const TensorInfo& inputInfo,
+void ReverseV2(const TensorInfo& inputInfo,
+               const TensorInfo& axisInfo,
                Decoder<float>& inputDecoder,
+               Decoder<int>& axisDecoder,
                Encoder<float>& outputEncoder);
 
-} // namespace armnn
\ No newline at end of file
+} // namespace armnn