diff options
Diffstat (limited to 'libgloss/bfin/include/builtins.h')
-rw-r--r-- | libgloss/bfin/include/builtins.h | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/libgloss/bfin/include/builtins.h b/libgloss/bfin/include/builtins.h new file mode 100644 index 000000000..7c9ece5b3 --- /dev/null +++ b/libgloss/bfin/include/builtins.h @@ -0,0 +1,295 @@ +/* + * The authors hereby grant permission to use, copy, modify, distribute, + * and license this software and its documentation for any purpose, provided + * that existing copyright notices are retained in all copies and that this + * notice is included verbatim in any distributions. No written agreement, + * license, or royalty fee is required for any of the authorized uses. + * Modifications to this software may be copyrighted by their authors + * and need not follow the licensing terms described here, provided that + * the new terms are clearly indicated on the first page of each file where + * they apply. + */ + +#ifdef _MISRA_RULES +#pragma diag(push) +#pragma diag(suppress:misra_rule_2_4) +#pragma diag(suppress:misra_rule_5_3) +#pragma diag(suppress:misra_rule_6_3) +#pragma diag(suppress:misra_rule_8_1) +#pragma diag(suppress:misra_rule_8_8) +#pragma diag(suppress:misra_rule_8_5) +#pragma diag(suppress:misra_rule_19_7) +#pragma diag(suppress:misra_rule_19_15) +#pragma diag(suppress:misra_rule_20_2) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if !defined(__NO_BUILTIN) + +/* VDSP -> GCC glue */ +#define __builtin_NOP() __asm__ __volatile__ ("NOP;") +#define __builtin_cli() ({ unsigned int __rval; __asm__ __volatile__ ("cli %0;" : "=r"(__rval)); __rval; }) +#define __builtin_sti(x) __asm__ __volatile__ ("sti %0;" : : "r"(x)) +#define __builtin_idle() __asm__ __volatile__ ("IDLE;") +#define __builtin_raise(x) __asm__ __volatile__ ("raise %0;" : : "r"(x)) +#define __builtin_excpt(x) __asm__ __volatile__ ("excpt %0;" : : "r"(x)) +#define __builtin_prefetch(x) __asm__ __volatile__ ("PREFETCH[%0];" : : "p"(x)) +#define __builtin_prefetchmodup(x) ({ void *__p = &(x); __asm__ __volatile__ ("PREFETCH[%0++];" : "+p"(__p)); __p; }) +#define __builtin_flushinv(x) __asm__ __volatile__ ("FLUSHINV[%0];" : : "p"(x)) +#define __builtin_flushinvmodup(x) ({ void *__p = &(x); __asm__ __volatile__ ("FLUSHINV[%0++];" : "+p"(__p)); __p; }) +#define __builtin_flush(x) __asm__ __volatile__ ("FLUSH[%0];" : : "p"(x)) +#define __builtin_flushmodup(x) ({ void *__p = &(x); __asm__ __volatile__ ("FLUSH[%0++];" : "+p"(__p)); __p; }) +#define __builtin_iflush(x) __asm__ __volatile__ ("IFLUSH[%0];" : : "p"(x)) +#define __builtin_iflushmodup(x) ({ void *__p = &(x); __asm__ __volatile__ ("IFLUSH[%0++];" : "+p"(__p)); __p; }) +#define __builtin_csync() __builtin_bfin_csync() +#define __builtin_ssync() __builtin_bfin_ssync() + +#endif /* __NO_BUILTIN */ + + +#if !defined(__NO_BUILTIN) && !defined(__NO_SHORTNAMES) + +#if (!defined(__DEFINED_NOP) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_NOP)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_NOP)))) + +#define __DEFINED_NOP + +/* Insert a normal 16 bit NOP, which is treated as volatile. +*/ + +#pragma inline +#pragma always_inline +static void NOP(void) { + __builtin_NOP(); +} + +#endif /* __DEFINED_NOP */ + +#if (!defined(__DEFINED_CLI) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_CLI)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_CLI)))) + +#define __DEFINED_CLI + +#pragma inline +#pragma always_inline +static unsigned int cli(void) { + unsigned int __rval = __builtin_cli(); + return __rval; +} + +#endif /* __DEFINED_CLI */ + +#if (!defined(__DEFINED_STI) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_STI)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_STI)))) + +#define __DEFINED_STI + +#pragma inline +#pragma always_inline +static void sti(unsigned int __a) { + __builtin_sti(__a); +} + +#endif /* __DEFINED_STI */ + +#if (!defined(__DEFINED_IDLE) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_IDLE)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_IDLE)))) + +#define __DEFINED_IDLE + +#pragma inline +#pragma always_inline +static void idle(void) { + __builtin_idle(); +} + +#endif /* __DEFINED_IDLE */ + +#if (!defined(__DEFINED_RAISE_INTR) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_RAISE_INTR)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_RAISE_INTR)))) + +#define __DEFINED_RAISE_INTR + +#define raise_intr(A) (__builtin_raise((A))) + +#endif /* __DEFINED_RAISE_INTR */ + +#if (!defined(__DEFINED_EXCPT) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_EXCPT)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_EXCPT)))) + +#define __DEFINED_EXCPT + +#define excpt(A) (__builtin_excpt((A))) + +#endif /* __DEFINED_EXCPT */ + +#if (!defined(__DEFINED_PREFETCH) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_PREFETCH)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_PREFETCH)))) + +#define __DEFINED_PREFETCH + +#pragma inline +#pragma always_inline +static void prefetch(void * __a) { + __builtin_prefetch(__a); +} + +#endif /* __DEFINED_PREFETCH */ + +#if (!defined(__DEFINED_PREFETCHMODUP) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_PREFETCHMODUP)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_PREFETCHMODUP)))) + +#define __DEFINED_PREFETCHMODUP + +#pragma inline +#pragma always_inline +static void * prefetchmodup(void * __a) { + void * __rval = __builtin_prefetchmodup(__a); + return __rval; +} + +#endif /* __DEFINED_PREFETCHMODUP */ + +#if (!defined(__DEFINED_FLUSHINV) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_FLUSHINV)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_FLUSHINV)))) + +#define __DEFINED_FLUSHINV + +#pragma inline +#pragma always_inline +static void flushinv(void * __a) { + __builtin_flushinv(__a); +} + +#endif /* __DEFINED_FLUSHINV */ + +#if (!defined(__DEFINED_FLUSHINVMODUP) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_FLUSHINVMODUP)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_FLUSHINVMODUP)))) + +#define __DEFINED_FLUSHINVMODUP + +#pragma inline +#pragma always_inline +static void * flushinvmodup(void * __a) { + void * __rval = __builtin_flushinvmodup(__a); + return __rval; +} + +#endif /* __DEFINED_FLUSHINVMODUP */ + +#if (!defined(__DEFINED_FLUSH) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_FLUSH)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_FLUSH)))) + +#define __DEFINED_FLUSH + +#pragma inline +#pragma always_inline +static void flush(void * __a) { + __builtin_flush(__a); +} + +#endif /* __DEFINED_FLUSH */ + +#if (!defined(__DEFINED_FLUSHMODUP) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_FLUSHMODUP)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_FLUSHMODUP)))) + +#define __DEFINED_FLUSHMODUP + +#pragma inline +#pragma always_inline +static void * flushmodup(void * __a) { + void * __rval = __builtin_flushmodup(__a); + return __rval; +} + +#endif /* __DEFINED_FLUSHMODUP */ + +#if (!defined(__DEFINED_IFLUSH) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_IFLUSH)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_IFLUSH)))) + +#define __DEFINED_IFLUSH + +#pragma inline +#pragma always_inline +static void iflush(void * __a) { + __builtin_iflush(__a); +} + +#endif /* __DEFINED_IFLUSH */ + +#if (!defined(__DEFINED_IFLUSHMODUP) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_IFLUSHMODUP)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_IFLUSHMODUP)))) + +#define __DEFINED_IFLUSHMODUP + +#pragma inline +#pragma always_inline +static void * iflushmodup(void * __a) { + void * __rval = __builtin_iflushmodup(__a); + return __rval; +} + +#endif /* __DEFINED_IFLUSHMODUP */ + +#if (!defined(__DEFINED_CSYNC) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_CSYNC)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_CSYNC)))) + +#define __DEFINED_CSYNC + +/* generate a csync instruction protected by CLI/STI for anomaly 05-00-0312; +** you can generate an unprotected csync by using csync_int +*/ + +#pragma inline +#pragma always_inline +static void csync(void) { + __builtin_csync(); +} + +#endif /* __DEFINED_CSYNC */ + +#if (!defined(__DEFINED_SSYNC) && \ + ((defined(__SPECIFIC_NAMES) && defined(__ENABLE_SSYNC)) || \ + (!defined(__SPECIFIC_NAMES) && !defined(__DISABLE_SSYNC)))) + +#define __DEFINED_SSYNC + +/* generate a ssync instruction protected by CLI/STI for anomaly 05-00-0312; +** you can generate an unprotected ssync by using ssync_int +*/ + +#pragma inline +#pragma always_inline +static void ssync(void) { + __builtin_ssync(); +} + +#endif /* __DEFINED_SSYNC */ + +#endif /* __NO_BUILTIN */ + +#ifdef _MISRA_RULES +#pragma diag(pop) +#endif + +#ifdef __cplusplus +} +#endif |