Clean up macro definitions in arm_compute headers

- Expose loose macros by prefixing "ARM_COMPUTE_"

Resolves: COMPMID-3701

Signed-off-by: Giorgio Arena <giorgio.arena@arm.com>
Change-Id: I4334b01c1a5cd8585f4a1ba2d870be956c61a83d
Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/4769
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>
Comments-Addressed: Arm Jenkins <bsgcomp@arm.com>
Tested-by: Arm Jenkins <bsgcomp@arm.com>

5 files changed, 182 insertions, 182 deletions

diff --git a/src/core/CL/CLTracePoint.cpp b/src/core/CL/CLTracePoint.cpp
index d603f40c26..c3d4899740 100644
--- a/src/core/CL/CLTracePoint.cpp
+++ b/src/core/CL/CLTracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -51,35 +51,35 @@ TracePoint::Args &&operator<<(TracePoint::Args &&tp, const ICLTensor *arg)
     return std::move(tp);
 }
 
-TRACE_TO_STRING(std::vector<ICLTensor *>)
-TRACE_TO_STRING(ICLMultiImage)
-TRACE_TO_STRING(ICLDetectionWindowArray)
-TRACE_TO_STRING(ICLKeyPointArray)
-TRACE_TO_STRING(ICLLKInternalKeypointArray)
-TRACE_TO_STRING(ICLCoefficientTableArray)
-TRACE_TO_STRING(ICLCoordinates2DArray)
-TRACE_TO_STRING(ICLOldValArray)
-TRACE_TO_STRING(cl::Buffer)
-TRACE_TO_STRING(ICLDistribution1D)
-TRACE_TO_STRING(ICLMultiHOG)
-TRACE_TO_STRING(ICLHOG)
-TRACE_TO_STRING(ICLLut)
-TRACE_TO_STRING(ICLSize2DArray)
-TRACE_TO_STRING(std::vector<const ICLTensor *>)
+ARM_COMPUTE_TRACE_TO_STRING(std::vector<ICLTensor *>)
+ARM_COMPUTE_TRACE_TO_STRING(ICLMultiImage)
+ARM_COMPUTE_TRACE_TO_STRING(ICLDetectionWindowArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLKeyPointArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLLKInternalKeypointArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLCoefficientTableArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLCoordinates2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICLOldValArray)
+ARM_COMPUTE_TRACE_TO_STRING(cl::Buffer)
+ARM_COMPUTE_TRACE_TO_STRING(ICLDistribution1D)
+ARM_COMPUTE_TRACE_TO_STRING(ICLMultiHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ICLHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ICLLut)
+ARM_COMPUTE_TRACE_TO_STRING(ICLSize2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(std::vector<const ICLTensor *>)
 
-CONST_PTR_CLASS(std::vector<ICLTensor *>)
-CONST_PTR_CLASS(ICLMultiImage)
-CONST_PTR_CLASS(ICLDetectionWindowArray)
-CONST_PTR_CLASS(ICLKeyPointArray)
-CONST_PTR_CLASS(ICLLKInternalKeypointArray)
-CONST_PTR_CLASS(ICLCoefficientTableArray)
-CONST_PTR_CLASS(ICLCoordinates2DArray)
-CONST_PTR_CLASS(ICLOldValArray)
-CONST_PTR_CLASS(cl::Buffer)
-CONST_PTR_CLASS(ICLDistribution1D)
-CONST_PTR_CLASS(ICLMultiHOG)
-CONST_PTR_CLASS(ICLHOG)
-CONST_PTR_CLASS(ICLLut)
-CONST_PTR_CLASS(ICLSize2DArray)
-CONST_PTR_CLASS(std::vector<const ICLTensor *>)
+ARM_COMPUTE_CONST_PTR_CLASS(std::vector<ICLTensor *>)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLMultiImage)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLDetectionWindowArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLKeyPointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLLKInternalKeypointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLCoefficientTableArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLCoordinates2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLOldValArray)
+ARM_COMPUTE_CONST_PTR_CLASS(cl::Buffer)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLDistribution1D)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLMultiHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLLut)
+ARM_COMPUTE_CONST_PTR_CLASS(ICLSize2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(std::vector<const ICLTensor *>)
 } // namespace arm_compute
diff --git a/src/core/NEON/NETracePoint.cpp b/src/core/NEON/NETracePoint.cpp
index bf48b411ec..756451d230 100644
--- a/src/core/NEON/NETracePoint.cpp
+++ b/src/core/NEON/NETracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -37,11 +37,11 @@ std::string to_string(const PaddingType &arg)
     return ((arg == PADDING_SAME) ? "PADDING_SAME" : "PADDING_VALID");
 }
 
-TRACE_TO_STRING(INELKInternalKeypointArray)
-TRACE_TO_STRING(std::unique_ptr<INEGEMMWrapperKernel>)
+ARM_COMPUTE_TRACE_TO_STRING(INELKInternalKeypointArray)
+ARM_COMPUTE_TRACE_TO_STRING(std::unique_ptr<INEGEMMWrapperKernel>)
 
-CONST_PTR_CLASS(INELKInternalKeypointArray)
-CONST_PTR_CLASS(std::unique_ptr<INEGEMMWrapperKernel>)
+ARM_COMPUTE_CONST_PTR_CLASS(INELKInternalKeypointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(std::unique_ptr<INEGEMMWrapperKernel>)
 
 template <>
 TracePoint::Args &&operator<<(TracePoint::Args &&tp, const PaddingType &arg)
diff --git a/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h b/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h
index 59f5c6c6b3..bc592193bf 100644
--- a/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h
+++ b/src/core/NEON/kernels/detail/NEDirectConvolutionDetail.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2020 Arm Limited.
+ * Copyright (c) 2017-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -64,7 +64,7 @@ inline float32x4x3_t load_matrix_row(const float *ptr, int weights_offset = 0)
  *
  * @return The loaded matrix.
  */
-template < typename T, REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
+template < typename T, ARM_COMPUTE_REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
 inline int32x4x3_t load_matrix_row(const T *ptr, int weights_offset = 0)
 {
     const int32x4_t v_weights_offset = vdupq_n_s32(weights_offset);
@@ -463,7 +463,7 @@ inline void convolve_3x3(const float *in_top, const float *in_mid, const float *
  * @param[in] input_offset Input quantization offset.
  *
  */
-template < typename T, REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
+template < typename T, ARM_COMPUTE_REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
 inline int32x4_t single_convolve_3x3_dilation(const T *in_top, const T *in_mid, const T *in_low,
                                               const int32x4x3_t &m0, const int32x4x3_t &m1, const int32x4x3_t &m2,
                                               size_t dilation_x, int32_t input_offset)
@@ -551,7 +551,7 @@ inline int32x4_t single_convolve_3x3_dilation(const T *in_top, const T *in_mid,
  * @param[in] input_offset Input quantization offset.
  *
  */
-template < typename T, REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
+template < typename T, ARM_COMPUTE_REQUIRES_TA(std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) >
 inline int32x4x2_t convolve_3x3_dilation(const T *in_top, const T *in_mid, const T *in_low, const int32x4x3_t &m0, const int32x4x3_t &m1, const int32x4x3_t &m2,
                                          const size_t dilation_x, unsigned int stridex, int input_offset)
 {
@@ -590,7 +590,7 @@ inline int32x4x2_t convolve_3x3_dilation(const T *in_top, const T *in_mid, const
  * @param[in]  input_offset Input quantization offset.
  *
  */
-template < bool accumulate, typename T1, typename T2, REQUIRES_TA(std::is_same<T1, uint8_t>::value || std::is_same<T1, int8_t>::value) >
+template < bool accumulate, typename T1, typename T2, ARM_COMPUTE_REQUIRES_TA(std::is_same<T1, uint8_t>::value || std::is_same<T1, int8_t>::value) >
 void convolve_3x3(const T1 *in_top, const T1 *in_mid, const T1 *in_low, T2 *out_ptr,
                   const int32x4x3_t &m0, const int32x4x3_t &m1, const int32x4x3_t &m2,
                   unsigned int stridex, int32_t input_offset)
diff --git a/src/core/TracePoint.cpp b/src/core/TracePoint.cpp
index d67faad868..69374fbc8c 100644
--- a/src/core/TracePoint.cpp
+++ b/src/core/TracePoint.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Arm Limited.
+ * Copyright (c) 2020-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -123,150 +123,150 @@ std::string to_ptr_string(const void *arg)
     return ss.str();
 }
 
-TRACE_TO_STRING(ThresholdType)
-TRACE_TO_STRING(IDetectionWindowArray)
-TRACE_TO_STRING(ICoordinates2DArray)
-TRACE_TO_STRING(IMultiImage)
+ARM_COMPUTE_TRACE_TO_STRING(ThresholdType)
+ARM_COMPUTE_TRACE_TO_STRING(IDetectionWindowArray)
+ARM_COMPUTE_TRACE_TO_STRING(ICoordinates2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(IMultiImage)
 using pair_uint = std::pair<unsigned int, unsigned int>;
-TRACE_TO_STRING(pair_uint)
-TRACE_TO_STRING(IKeyPointArray)
-TRACE_TO_STRING(IDistribution1D)
-TRACE_TO_STRING(IHOG)
-TRACE_TO_STRING(ILut)
-TRACE_TO_STRING(IPyramid)
-TRACE_TO_STRING(IMultiHOG)
-TRACE_TO_STRING(ISize2DArray)
-TRACE_TO_STRING(MemoryGroup)
-TRACE_TO_STRING(BoxNMSLimitInfo)
-TRACE_TO_STRING(DepthwiseConvolutionReshapeInfo)
-TRACE_TO_STRING(DWCWeightsKernelInfo)
-TRACE_TO_STRING(DWCKernelInfo)
-TRACE_TO_STRING(GEMMLHSMatrixInfo)
-TRACE_TO_STRING(GEMMRHSMatrixInfo)
-TRACE_TO_STRING(GEMMKernelInfo)
-TRACE_TO_STRING(InstanceNormalizationLayerKernelInfo)
-TRACE_TO_STRING(SoftmaxKernelInfo)
-TRACE_TO_STRING(FuseBatchNormalizationType)
-TRACE_TO_STRING(DirectConvolutionLayerOutputStageKernelInfo)
-TRACE_TO_STRING(FFTScaleKernelInfo)
-TRACE_TO_STRING(GEMMLowpOutputStageInfo)
-TRACE_TO_STRING(FFT1DInfo)
-TRACE_TO_STRING(FFT2DInfo)
-TRACE_TO_STRING(FFTDigitReverseKernelInfo)
-TRACE_TO_STRING(FFTRadixStageKernelInfo)
-TRACE_TO_STRING(IWeightsManager)
-TRACE_TO_STRING(Coordinates2D)
-TRACE_TO_STRING(ITensorInfo)
-TRACE_TO_STRING(InternalKeypoint)
-TRACE_TO_STRING(arm_gemm::Nothing)
-TRACE_TO_STRING(PixelValue)
-TRACE_TO_STRING(std::allocator<ITensor const *>)
+ARM_COMPUTE_TRACE_TO_STRING(pair_uint)
+ARM_COMPUTE_TRACE_TO_STRING(IKeyPointArray)
+ARM_COMPUTE_TRACE_TO_STRING(IDistribution1D)
+ARM_COMPUTE_TRACE_TO_STRING(IHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ILut)
+ARM_COMPUTE_TRACE_TO_STRING(IPyramid)
+ARM_COMPUTE_TRACE_TO_STRING(IMultiHOG)
+ARM_COMPUTE_TRACE_TO_STRING(ISize2DArray)
+ARM_COMPUTE_TRACE_TO_STRING(MemoryGroup)
+ARM_COMPUTE_TRACE_TO_STRING(BoxNMSLimitInfo)
+ARM_COMPUTE_TRACE_TO_STRING(DepthwiseConvolutionReshapeInfo)
+ARM_COMPUTE_TRACE_TO_STRING(DWCWeightsKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(DWCKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMLHSMatrixInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMRHSMatrixInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(InstanceNormalizationLayerKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(SoftmaxKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FuseBatchNormalizationType)
+ARM_COMPUTE_TRACE_TO_STRING(DirectConvolutionLayerOutputStageKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFTScaleKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(GEMMLowpOutputStageInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFT1DInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFT2DInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFTDigitReverseKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(FFTRadixStageKernelInfo)
+ARM_COMPUTE_TRACE_TO_STRING(IWeightsManager)
+ARM_COMPUTE_TRACE_TO_STRING(Coordinates2D)
+ARM_COMPUTE_TRACE_TO_STRING(ITensorInfo)
+ARM_COMPUTE_TRACE_TO_STRING(InternalKeypoint)
+ARM_COMPUTE_TRACE_TO_STRING(arm_gemm::Nothing)
+ARM_COMPUTE_TRACE_TO_STRING(PixelValue)
+ARM_COMPUTE_TRACE_TO_STRING(std::allocator<ITensor const *>)
 using array_f32 = std::array<float, 9ul>;
-TRACE_TO_STRING(array_f32)
+ARM_COMPUTE_TRACE_TO_STRING(array_f32)
 
-CONST_REF_CLASS(arm_gemm::GemmArgs)
-CONST_REF_CLASS(arm_gemm::Nothing)
-CONST_REF_CLASS(arm_gemm::Activation)
-CONST_REF_CLASS(DirectConvolutionLayerOutputStageKernelInfo)
-CONST_REF_CLASS(GEMMLowpOutputStageInfo)
-CONST_REF_CLASS(DWCWeightsKernelInfo)
-CONST_REF_CLASS(DWCKernelInfo)
-CONST_REF_CLASS(DepthwiseConvolutionReshapeInfo)
-CONST_REF_CLASS(GEMMLHSMatrixInfo)
-CONST_REF_CLASS(GEMMRHSMatrixInfo)
-CONST_REF_CLASS(GEMMKernelInfo)
-CONST_REF_CLASS(InstanceNormalizationLayerKernelInfo)
-CONST_REF_CLASS(SoftmaxKernelInfo)
-CONST_REF_CLASS(PaddingMode)
-CONST_REF_CLASS(Coordinates)
-CONST_REF_CLASS(FFT1DInfo)
-CONST_REF_CLASS(FFT2DInfo)
-CONST_REF_CLASS(FFTDigitReverseKernelInfo)
-CONST_REF_CLASS(FFTRadixStageKernelInfo)
-CONST_REF_CLASS(FFTScaleKernelInfo)
-CONST_REF_CLASS(MemoryGroup)
-CONST_REF_CLASS(IWeightsManager)
-CONST_REF_CLASS(ActivationLayerInfo)
-CONST_REF_CLASS(PoolingLayerInfo)
-CONST_REF_CLASS(PadStrideInfo)
-CONST_REF_CLASS(NormalizationLayerInfo)
-CONST_REF_CLASS(Size2D)
-CONST_REF_CLASS(WeightsInfo)
-CONST_REF_CLASS(GEMMInfo)
-CONST_REF_CLASS(GEMMReshapeInfo)
-CONST_REF_CLASS(Window)
-CONST_REF_CLASS(BorderSize)
-CONST_REF_CLASS(BorderMode)
-CONST_REF_CLASS(PhaseType)
-CONST_REF_CLASS(MagnitudeType)
-CONST_REF_CLASS(Termination)
-CONST_REF_CLASS(ReductionOperation)
-CONST_REF_CLASS(InterpolationPolicy)
-CONST_REF_CLASS(SamplingPolicy)
-CONST_REF_CLASS(DataType)
-CONST_REF_CLASS(DataLayout)
-CONST_REF_CLASS(Channel)
-CONST_REF_CLASS(ConvertPolicy)
-CONST_REF_CLASS(TensorShape)
-CONST_REF_CLASS(PixelValue)
-CONST_REF_CLASS(Strides)
-CONST_REF_CLASS(WinogradInfo)
-CONST_REF_CLASS(RoundingPolicy)
-CONST_REF_CLASS(MatrixPattern)
-CONST_REF_CLASS(NonLinearFilterFunction)
-CONST_REF_CLASS(ThresholdType)
-CONST_REF_CLASS(ROIPoolingLayerInfo)
-CONST_REF_CLASS(BoundingBoxTransformInfo)
-CONST_REF_CLASS(ComparisonOperation)
-CONST_REF_CLASS(ArithmeticOperation)
-CONST_REF_CLASS(BoxNMSLimitInfo)
-CONST_REF_CLASS(FuseBatchNormalizationType)
-CONST_REF_CLASS(ElementWiseUnary)
-CONST_REF_CLASS(ComputeAnchorsInfo)
-CONST_REF_CLASS(PriorBoxLayerInfo)
-CONST_REF_CLASS(DetectionOutputLayerInfo)
-CONST_REF_CLASS(Coordinates2D)
-CONST_REF_CLASS(std::vector<const ITensor *>)
-CONST_REF_CLASS(std::vector<ITensor *>)
-CONST_REF_CLASS(std::vector<pair_uint>)
-CONST_REF_CLASS(pair_uint)
-CONST_REF_CLASS(array_f32)
+ARM_COMPUTE_CONST_REF_CLASS(arm_gemm::GemmArgs)
+ARM_COMPUTE_CONST_REF_CLASS(arm_gemm::Nothing)
+ARM_COMPUTE_CONST_REF_CLASS(arm_gemm::Activation)
+ARM_COMPUTE_CONST_REF_CLASS(DirectConvolutionLayerOutputStageKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMLowpOutputStageInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DWCWeightsKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DWCKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DepthwiseConvolutionReshapeInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMLHSMatrixInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMRHSMatrixInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(InstanceNormalizationLayerKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(SoftmaxKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PaddingMode)
+ARM_COMPUTE_CONST_REF_CLASS(Coordinates)
+ARM_COMPUTE_CONST_REF_CLASS(FFT1DInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFT2DInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFTDigitReverseKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFTRadixStageKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FFTScaleKernelInfo)
+ARM_COMPUTE_CONST_REF_CLASS(MemoryGroup)
+ARM_COMPUTE_CONST_REF_CLASS(IWeightsManager)
+ARM_COMPUTE_CONST_REF_CLASS(ActivationLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PoolingLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PadStrideInfo)
+ARM_COMPUTE_CONST_REF_CLASS(NormalizationLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(Size2D)
+ARM_COMPUTE_CONST_REF_CLASS(WeightsInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMInfo)
+ARM_COMPUTE_CONST_REF_CLASS(GEMMReshapeInfo)
+ARM_COMPUTE_CONST_REF_CLASS(Window)
+ARM_COMPUTE_CONST_REF_CLASS(BorderSize)
+ARM_COMPUTE_CONST_REF_CLASS(BorderMode)
+ARM_COMPUTE_CONST_REF_CLASS(PhaseType)
+ARM_COMPUTE_CONST_REF_CLASS(MagnitudeType)
+ARM_COMPUTE_CONST_REF_CLASS(Termination)
+ARM_COMPUTE_CONST_REF_CLASS(ReductionOperation)
+ARM_COMPUTE_CONST_REF_CLASS(InterpolationPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(SamplingPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(DataType)
+ARM_COMPUTE_CONST_REF_CLASS(DataLayout)
+ARM_COMPUTE_CONST_REF_CLASS(Channel)
+ARM_COMPUTE_CONST_REF_CLASS(ConvertPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(TensorShape)
+ARM_COMPUTE_CONST_REF_CLASS(PixelValue)
+ARM_COMPUTE_CONST_REF_CLASS(Strides)
+ARM_COMPUTE_CONST_REF_CLASS(WinogradInfo)
+ARM_COMPUTE_CONST_REF_CLASS(RoundingPolicy)
+ARM_COMPUTE_CONST_REF_CLASS(MatrixPattern)
+ARM_COMPUTE_CONST_REF_CLASS(NonLinearFilterFunction)
+ARM_COMPUTE_CONST_REF_CLASS(ThresholdType)
+ARM_COMPUTE_CONST_REF_CLASS(ROIPoolingLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(BoundingBoxTransformInfo)
+ARM_COMPUTE_CONST_REF_CLASS(ComparisonOperation)
+ARM_COMPUTE_CONST_REF_CLASS(ArithmeticOperation)
+ARM_COMPUTE_CONST_REF_CLASS(BoxNMSLimitInfo)
+ARM_COMPUTE_CONST_REF_CLASS(FuseBatchNormalizationType)
+ARM_COMPUTE_CONST_REF_CLASS(ElementWiseUnary)
+ARM_COMPUTE_CONST_REF_CLASS(ComputeAnchorsInfo)
+ARM_COMPUTE_CONST_REF_CLASS(PriorBoxLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(DetectionOutputLayerInfo)
+ARM_COMPUTE_CONST_REF_CLASS(Coordinates2D)
+ARM_COMPUTE_CONST_REF_CLASS(std::vector<const ITensor *>)
+ARM_COMPUTE_CONST_REF_CLASS(std::vector<ITensor *>)
+ARM_COMPUTE_CONST_REF_CLASS(std::vector<pair_uint>)
+ARM_COMPUTE_CONST_REF_CLASS(pair_uint)
+ARM_COMPUTE_CONST_REF_CLASS(array_f32)
 
-CONST_PTR_CLASS(ITensor)
-CONST_PTR_CLASS(ITensorInfo)
-CONST_PTR_CLASS(IWeightsManager)
-CONST_PTR_CLASS(InternalKeypoint)
-CONST_PTR_CLASS(IDetectionWindowArray)
-CONST_PTR_CLASS(ICoordinates2DArray)
-CONST_PTR_CLASS(IMultiImage)
-CONST_PTR_CLASS(Window)
-CONST_PTR_CLASS(IKeyPointArray)
-CONST_PTR_CLASS(HOGInfo)
-CONST_PTR_CLASS(IDistribution1D)
-CONST_PTR_CLASS(IHOG)
-CONST_PTR_CLASS(ILut)
-CONST_PTR_CLASS(IPyramid)
-CONST_PTR_CLASS(IMultiHOG)
-CONST_PTR_CLASS(ISize2DArray)
-CONST_PTR_CLASS(std::allocator<ITensor const *>)
-CONST_PTR_CLASS(std::vector<unsigned int>)
+ARM_COMPUTE_CONST_PTR_CLASS(ITensor)
+ARM_COMPUTE_CONST_PTR_CLASS(ITensorInfo)
+ARM_COMPUTE_CONST_PTR_CLASS(IWeightsManager)
+ARM_COMPUTE_CONST_PTR_CLASS(InternalKeypoint)
+ARM_COMPUTE_CONST_PTR_CLASS(IDetectionWindowArray)
+ARM_COMPUTE_CONST_PTR_CLASS(ICoordinates2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(IMultiImage)
+ARM_COMPUTE_CONST_PTR_CLASS(Window)
+ARM_COMPUTE_CONST_PTR_CLASS(IKeyPointArray)
+ARM_COMPUTE_CONST_PTR_CLASS(HOGInfo)
+ARM_COMPUTE_CONST_PTR_CLASS(IDistribution1D)
+ARM_COMPUTE_CONST_PTR_CLASS(IHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ILut)
+ARM_COMPUTE_CONST_PTR_CLASS(IPyramid)
+ARM_COMPUTE_CONST_PTR_CLASS(IMultiHOG)
+ARM_COMPUTE_CONST_PTR_CLASS(ISize2DArray)
+ARM_COMPUTE_CONST_PTR_CLASS(std::allocator<ITensor const *>)
+ARM_COMPUTE_CONST_PTR_CLASS(std::vector<unsigned int>)
 
-CONST_REF_SIMPLE(bool)
-CONST_REF_SIMPLE(uint64_t)
-CONST_REF_SIMPLE(int64_t)
-CONST_REF_SIMPLE(uint32_t)
-CONST_REF_SIMPLE(int32_t)
-CONST_REF_SIMPLE(int16_t)
-CONST_REF_SIMPLE(float)
+ARM_COMPUTE_CONST_REF_SIMPLE(bool)
+ARM_COMPUTE_CONST_REF_SIMPLE(uint64_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(int64_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(uint32_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(int32_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(int16_t)
+ARM_COMPUTE_CONST_REF_SIMPLE(float)
 
-CONST_PTR_ADDRESS(float)
-CONST_PTR_ADDRESS(uint8_t)
-CONST_PTR_ADDRESS(void)
-CONST_PTR_ADDRESS(short)
-CONST_PTR_ADDRESS(int)
-CONST_PTR_ADDRESS(uint64_t)
-CONST_PTR_ADDRESS(uint32_t)
-CONST_PTR_ADDRESS(uint16_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(float)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint8_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(void)
+ARM_COMPUTE_CONST_PTR_ADDRESS(short)
+ARM_COMPUTE_CONST_PTR_ADDRESS(int)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint64_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint32_t)
+ARM_COMPUTE_CONST_PTR_ADDRESS(uint16_t)
 
 template <>
 TracePoint::Args &&operator<<(TracePoint::Args &&tp, const uint16_t &arg)
diff --git a/src/core/utils/helpers/bit_ops.h b/src/core/utils/helpers/bit_ops.h
index ef60214c9f..954fb56460 100644
--- a/src/core/utils/helpers/bit_ops.h
+++ b/src/core/utils/helpers/bit_ops.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2020 Arm Limited.
+ * Copyright (c) 2018-2021 Arm Limited.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -41,7 +41,7 @@ namespace bit_ops
  *
  * @return True if the idx-th bit is set else false
  */
-template <typename T, REQUIRES_TA(std::is_integral<T>::value)>
+template <typename T, ARM_COMPUTE_REQUIRES_TA(std::is_integral<T>::value)>
 bool is_bit_set(T v, unsigned int idx)
 {
     return (v & 1 << idx) != 0;