core_compatiable.h

/*
 * Copyright (c) 2019 Nuclei Limited. All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the License); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef __CORE_COMPATIABLE_H__
#define __CORE_COMPATIABLE_H__
 
#ifdef __cplusplus
 extern "C" {
#endif
 
#include "core_feature_base.h"
 
/* ===== ARM Compatiable Functions ===== */
#define __ISB()                             __RWMB()
 
#define __DSB()                             __RWMB()
 
#define __DMB()                             __RWMB()
 
#define __LDRBT(ptr)                        __LB((ptr))
 
#define __LDRHT(ptr)                        __LH((ptr))
 
#define __LDRT(ptr)                         __LW((ptr))
 
#define __STRBT(val, ptr)                   __SB((ptr), (val))
 
#define __STRHT(val, ptr)                   __SH((ptr), (val))
 
#define __STRT(val, ptr)                    __SW((ptr), (val))
 
/* ===== Saturation Operations ===== */
#if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1)
#define __SSAT(val, sat)          __RV_SCLIP32((val), (sat-1))
#else
__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
{
    if ((sat >= 1U) && (sat <= 32U)) {
        const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
        const int32_t min = -1 - max ;
        if (val > max) {
            return max;
        } else if (val < min) {
            return min;
        }
    }
    return val;
}
#endif
 
#if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1)
#define __USAT(val, sat)        __RV_UCLIP32((val), (sat))
#else
__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
{
    if (sat <= 31U) {
        const uint32_t max = ((1U << sat) - 1U);
        if (val > (int32_t)max) {
            return max;
        } else if (val < 0) {
            return 0U;
        }
    }
    return (uint32_t)val;
}
#endif
 
/* ===== Data Processing Operations ===== */
__STATIC_FORCEINLINE uint32_t __REV(uint32_t value)
{
    uint32_t result;
 
    result =  ((value & 0xff000000) >> 24)
        | ((value & 0x00ff0000) >> 8 )
        | ((value & 0x0000ff00) << 8 )
        | ((value & 0x000000ff) << 24);
    return result;
}
 
__STATIC_FORCEINLINE uint32_t __REV16(uint32_t value)
{
    uint32_t result;
    result =  ((value & 0xff000000) >> 8)
        | ((value & 0x00ff0000) << 8 )
        | ((value & 0x0000ff00) >> 8 )
        | ((value & 0x000000ff) << 8) ;
 
    return result;
}
 
__STATIC_FORCEINLINE int16_t __REVSH(int16_t value)
{
    int16_t result;
    result = ((value & 0xff00) >> 8) | ((value & 0x00ff) << 8);
    return result;
}
 
__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
{
    op2 = op2 & 0x1F;
    if (op2 == 0U) {
      return op1;
    }
    return (op1 >> op2) | (op1 << (32U - op2));
}
 
#if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1)
#define __RBIT(value)           __RV_BITREVI((value), 31)
#else
__STATIC_FORCEINLINE uint32_t __RBIT(uint32_t value)
{
    uint32_t result;
    uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */
 
    result = value; /* r will be reversed bits of v; first get LSB of v */
    for (value >>= 1U; value != 0U; value >>= 1U) {
        result <<= 1U;
        result |= value & 1U;
        s--;
    }
    result <<= s; /* shift when v's highest bits are zero */
    return result;
}
#endif /* defined(__DSP_PRESENT) && (__DSP_PRESENT == 1) */
 
#if defined(__DSP_PRESENT) && (__DSP_PRESENT == 1)
#define __CLZ(data)         __RV_CLZ32(data)
#else
__STATIC_FORCEINLINE uint8_t __CLZ(uint32_t data)
{
    uint8_t ret = 0;
    uint32_t temp = ~data;
    while (temp & 0x80000000) {
          temp <<= 1;
          ret++;
    }
    return ret;
}
#endif /* defined(__DSP_PRESENT) && (__DSP_PRESENT == 1) */
 
__STATIC_FORCEINLINE unsigned long __CTZ(unsigned long data)
{
    unsigned long ret = 0;
 
    while (!(data & 1UL)) {
        ret++;
        data = data >> 1;
    }
 
    return ret;
}
 
#if __RISCV_XLEN == 32
#define __EXPD_BYTE(x)      ((unsigned long)(((unsigned long)(x) <<  0) | \
                                    ((unsigned long)(x) <<  8) | \
                                    ((unsigned long)(x) << 16) | \
                                    ((unsigned long)(x) << 24)))
#elif __RISCV_XLEN == 64
#define __EXPD_BYTE(x)      ((unsigned long)(((unsigned long)(x) <<  0) | \
                                    ((unsigned long)(x) <<  8) | \
                                    ((unsigned long)(x) << 16) | \
                                    ((unsigned long)(x) << 24) | \
                                    ((unsigned long)(x) << 32) | \
                                    ((unsigned long)(x) << 40) | \
                                    ((unsigned long)(x) << 48) | \
                                    ((unsigned long)(x) << 56)))
#endif
 /* End of Doxygen Group NMSIS_Core_ARMCompatiable_Functions */
 
#ifdef __cplusplus
}
#endif
#endif /* __CORE_COMPATIABLE_H__ */