diff options
Diffstat (limited to 'sim/common/sim-inline.h')
| -rw-r--r-- | sim/common/sim-inline.h | 810 |
1 files changed, 810 insertions, 0 deletions
diff --git a/sim/common/sim-inline.h b/sim/common/sim-inline.h new file mode 100644 index 00000000000..300658d374e --- /dev/null +++ b/sim/common/sim-inline.h @@ -0,0 +1,810 @@ +/* This file is part of the program psim. + + Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au> + Copyright (C) 1997, Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + */ + + +#ifndef SIM_INLINE_H +#define SIM_INLINE_H + + +/* INLINE CODE SELECTION: + + GCC -O3 attempts to inline any function or procedure in scope. The + options below facilitate finer grained control over what is and + what is not inlined. In particular, it allows the selection of + modules for inlining. Doing this allows the compiler to both + eliminate the overhead of function calls and (as a consequence) + also eliminate further dead code. + + On a CISC (x86) I've found that I can achieve an order of magintude + speed improvement (x3-x5). In the case of RISC (sparc) while the + performance gain isn't as great it is still significant. + + Each module is controled by the macro <module>_INLINE which can + have the values described below + + 0 (ZERO) + + Do not inline any thing for the given module + + The following bit fields values can be combined: + + H_REVEALS_MODULE: + C_REVEALS_MODULE: + + Include the C file for the module into the file being + compiled. The actual inlining is controlled separatly. + + While of no apparent benefit, this makes it possible for the + included module, when compiled, to inline its calls to what + would otherwize be external functions. + + {C_,H_} Determines where the module is inlined. A + H_REVEALS_MODULE will be included everywhere. + + INLINE_GLOBALS: + + Make external functions within the module `inline'. Thus if + the module is included into a file being compiled, calls to + the included modules funtions can be eliminated. INLINE_MODULE + implies REVEAL_MODULE. + + INLINE_LOCALS: + + Make internal (static) functions within the module `inline'. + + + CODING STYLE: + + The inline ability is enabled by specifying every data and function + declaration and definition using one of the following methods: + + + GLOBAL INLINE FUNCTIONS: + + Such functions are small and used heavily. Inlining them + will eliminate an unnecessary function call overhead. + + .h: INLINE_OURPKG (void) ourpkg_func + (int x, + int y); + + .c: INLINE_OURPKG (void) + ourpkg_func (int x, + int y) + { + ... + } + + + GLOBAL INLINE VARIABLES: + + This doesn't make much sense. + + + GLOBAL NON-INLINE (EXTERN) FUNCTIONS AND VARIABLES: + + These include functions with varargs parameters. It can + also include large rarely used functions that contribute + little when inlined. + + .h: extern int ourpkg_print + (char *fmt, ...); + extern int a_global_variable; + + .c: #if EXTERN_OURPKG_P + int + ourpkg_print (char *fmt, + ...) + { + ... + } + #endif + #if EXTERN_OURPKG_P + int a_global_variable = 1; + #endif + + + LOCAL (STATIC) FUNCTIONS: + + These can either be marked inline or just static static vis: + + .h: STATIC_INLINE_OURPKG (int) ourpkg_staticf (void); + .c: STATIC_INLINE_OURPKG (int) + ourpkg_staticf (void) + { + .. + } + + .h: STATIC_OURPKG (int) ourpkg_staticf (void); + .c: STATIC_OURPKG (int) + ourpkg_staticf (void) + { + .. + } + + + All .h files: + + + All modules must wrap their .h code in the following: + + #ifndef OURPKG_H + #define OURPKG_H + ... code proper ... + #endif + + In addition, modules that want to allow global inlining must + include the lines (below) at the end of the .h file. (FIXME: + Shouldn't be needed). + + #if H_REVEALS_MODULE_P (OURPKG_INLINE) + #include "ourpkg.c" + #endif + + + All .c files: + + All modules must wrap their .c code in the following + + #ifndef OURPKG_C + #define OURPKG_C + ... code proper ... + #endif + + + NOW IT WORKS: + + 0: + + Since no inlining is defined. All macro's get standard defaults + (extern, static, ...). + + + + H_REVEALS_MODULE (alt includes our): + + + altprog.c defines ALTPROG_C and then includes sim-inline.h. + + In sim-inline.h the expression `` H_REVEALS_MODULE_P + (OURPROG_INLINE) && ! defined (OURPROG_C) && REVEAL_MODULE_P + (OURPROG_INLINE) '' is TRUE so it defines *_OURPROG as static + and EXTERN_OURPROG_P as FALSE. + + altprog.c includes ourprog.h. + + In ourprog.h the expression ``H_REVEALS_MODULE_P + (OURPROG_INLINE)'' is TRUE so it includes ourprog.c. + + Consequently, all the code in ourprog.c is visible and static in + the file altprog.c + + + + H_REVEALS_MODULE (our includes our): + + + ourprog.c defines OURPROG_C and then includes sim-inline.h. + + In sim-inline.h the term `` ! defined (OURPROG_C) '' is FALSE so + it defines *_OURPROG as non-static and EXTERN_OURPROG_P as TRUE. + + ourprog.c includes ourprog.h. + + In ourprog.h the expression ``H_REVEALS_MODULE_P + (OURPROG_INLINE)'' is true so it includes ourprog.c. + + In ourprog.c (second include) the expression defined (OURPROG_C) + and so the body is not re-included. + + Consequently, ourprog.o will contain a non-static copy of all + the exported symbols. + + + + C_REVEALS_MODULE (alt includes our): + + + altprog.c defines ALTPROG_C and then includes sim-inline.c + + sim-inline.c defines C_INLINE_C and then includes sim-inline.h + + In sim-inline.h the expression `` defined (SIM_INLINE) && ! + defined (OURPROG_C) && REVEAL_MODULE_P (OURPROG_INLINE) '' is + true so it defines *_OURPROG as static and EXTERN_OURPROG_P as + FALSE. + + In sim-inline.c the expression ``C_REVEALS_MODULE_P + (OURPROG_INLINE)'' is true so it includes ourprog.c. + + Consequently, all the code in ourprog.c is visible and static in + the file altprog.c. + + + + C_REVEALS_MODULE (our includes our): + + + ourprog.c defines OURPROG_C and then includes sim-inline.c + + sim-inline.c defines C_INLINE_C and then includes sim-inline.h + + In sim-inline.h the term `` ! defined (OURPROG_C) '' is FALSE + so it defines *_OURPROG as non-static and EXTERN_OURPROG_P as + TRUE. + + Consequently, ourprog.o will contain a non-static copy of all + the exported symbols. + + + + REALITY CHECK: + + This is not for the faint hearted. I've seen GCC get up to 500mb + trying to compile what this can create. */ + +#define H_REVEALS_MODULE 1 +#define C_REVEALS_MODULE 2 +#define INLINE_GLOBALS 4 +#define INLINE_LOCALS 8 + +#define REGPARM_MODULE 32 + +#define ALL_H_INLINE (H_REVEALS_MODULE | INLINE_GLOBALS | INLINE_LOCALS) +#define ALL_C_INLINE (C_REVEALS_MODULE | INLINE_GLOBALS | INLINE_LOCALS) + + +/* Default macro to simplify control several of key the inlines */ + +#ifndef DEFAULT_INLINE +#define DEFAULT_INLINE INLINE_LOCALS +#endif + +#define REVEAL_MODULE_P(X) (X & (H_REVEALS_MODULE | C_REVEALS_MODULE)) +#define H_REVEALS_MODULE_P(X) ((X & H_REVEALS_MODULE)) +#define C_REVEALS_MODULE_P(X) ((X & C_REVEALS_MODULE)) + + +#ifndef HAVE_INLINE +#ifdef __GNUC__ +#define HAVE_INLINE +#endif +#endif + + +/* Your compilers inline prefix */ + +#ifndef INLINE +#if defined (__GNUC__) && defined (__OPTIMIZE__) +#define INLINE __inline__ +#else +#define INLINE /*inline*/ +#endif +#endif + +/* ??? Temporary, pending decision to always use extern inline and do a vast + cleanup of inline support. */ +#ifndef INLINE2 +#if defined (__GNUC__) +#define INLINE2 __inline__ +#else +#define INLINE2 /*inline*/ +#endif +#endif + + +/* Your compiler's static inline prefix */ + +#ifndef STATIC_INLINE +#define STATIC_INLINE static INLINE +#endif + + +/* Your compiler's extern inline prefix */ + +#ifndef EXTERN_INLINE +#define EXTERN_INLINE extern INLINE2 +#endif + + +/* Your compiler's no-return reserved word */ + +#ifndef NORETURN +#define NORETURN +#endif + + + +/* Your compilers's unused reserved word */ + +#if !defined (UNUSED) +#if (!defined (__GNUC__) \ + || (__GNUC__ < 2) \ + || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)) +#define UNUSED +#else +#define UNUSED __attribute__((__unused__)) +#endif +#endif + + + + +/* Your compilers nonstandard function call mechanism prefix */ + +#if !defined REGPARM +#if defined (__GNUC__) && (defined (__i386__) || defined (__i486__) || defined (__i586__) || defined (__i686__)) +#if (WITH_REGPARM && WITH_STDCALL) +#define REGPARM __attribute__((__regparm__(WITH_REGPARM),__stdcall__)) +#else +#if (WITH_REGPARM && !WITH_STDCALL) +#define REGPARM __attribute__((__regparm__(WITH_REGPARM))) +#else +#if (!WITH_REGPARM && WITH_STDCALL) +#define REGPARM __attribute__((__stdcall__)) +#endif +#endif +#endif +#endif +#endif + +#if !defined REGPARM +#define REGPARM +#endif + + + +/* ***** + sim-bits and sim-endian are treated differently from the rest + of the modules below. Their default value is ALL_H_INLINE. + The rest are ALL_C_INLINE. Don't blink, you'll miss it! + ***** + */ + +/* sim-bits */ + +#if !defined (SIM_BITS_INLINE) && (DEFAULT_INLINE) +# define SIM_BITS_INLINE (ALL_H_INLINE) +#endif + +#if (SIM_BITS_INLINE & REGPARM_MODULE) +# define REGPARM_SIM_BITS REGPARM +#else +# define REGPARM_SIM_BITS +#endif + +#if ((H_REVEALS_MODULE_P (SIM_BITS_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SIM_BITS_C) \ + && (REVEAL_MODULE_P (SIM_BITS_INLINE))) +# if (SIM_BITS_INLINE & INLINE_GLOBALS) +# define INLINE_SIM_BITS(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SIM_BITS_P 0 +# else +# define INLINE_SIM_BITS(TYPE) static TYPE UNUSED REGPARM_SIM_BITS +# define EXTERN_SIM_BITS_P 0 +# endif +#else +# define INLINE_SIM_BITS(TYPE) TYPE REGPARM_SIM_BITS +# define EXTERN_SIM_BITS_P 1 +#endif + +#if (SIM_BITS_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SIM_BITS(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SIM_BITS(TYPE) static TYPE REGPARM_SIM_BITS +#endif + +#define STATIC_SIM_BITS(TYPE) static TYPE + + + +/* sim-core */ + +#if !defined (SIM_CORE_INLINE) && (DEFAULT_INLINE) +# define SIM_CORE_INLINE ALL_C_INLINE +#endif + +#if (SIM_CORE_INLINE & REGPARM_MODULE) +# define REGPARM_SIM_CORE REGPARM +#else +# define REGPARM_SIM_CORE +#endif + +#if ((H_REVEALS_MODULE_P (SIM_CORE_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SIM_CORE_C) \ + && (REVEAL_MODULE_P (SIM_CORE_INLINE))) +# if (SIM_CORE_INLINE & INLINE_GLOBALS) +# define INLINE_SIM_CORE(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SIM_CORE_P 0 +#else +# define INLINE_SIM_CORE(TYPE) static TYPE UNUSED REGPARM_SIM_CORE +# define EXTERN_SIM_CORE_P 0 +#endif +#else +# define INLINE_SIM_CORE(TYPE) TYPE REGPARM_SIM_CORE +# define EXTERN_SIM_CORE_P 1 +#endif + +#if (SIM_CORE_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SIM_CORE(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SIM_CORE(TYPE) static TYPE REGPARM_SIM_CORE +#endif + +#define STATIC_SIM_CORE(TYPE) static TYPE + + + +/* sim-endian */ + +#if !defined (SIM_ENDIAN_INLINE) && (DEFAULT_INLINE) +# define SIM_ENDIAN_INLINE ALL_H_INLINE +#endif + +#if (SIM_ENDIAN_INLINE & REGPARM_MODULE) +# define REGPARM_SIM_ENDIAN REGPARM +#else +# define REGPARM_SIM_ENDIAN +#endif + +#if ((H_REVEALS_MODULE_P (SIM_ENDIAN_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SIM_ENDIAN_C) \ + && (REVEAL_MODULE_P (SIM_ENDIAN_INLINE))) +# if (SIM_ENDIAN_INLINE & INLINE_GLOBALS) +# define INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SIM_ENDIAN_P 0 +# else +# define INLINE_SIM_ENDIAN(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN +# define EXTERN_SIM_ENDIAN_P 0 +# endif +#else +# define INLINE_SIM_ENDIAN(TYPE) TYPE REGPARM_SIM_ENDIAN +# define EXTERN_SIM_ENDIAN_P 1 +#endif + +#if (SIM_ENDIAN_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SIM_ENDIAN(TYPE) static TYPE REGPARM_SIM_ENDIAN +#endif + +#define STATIC_SIM_ENDIAN(TYPE) static TYPE + + + +/* sim-events */ + +#if !defined (SIM_EVENTS_INLINE) && (DEFAULT_INLINE) +# define SIM_EVENTS_INLINE ALL_C_INLINE +#endif + +#if (SIM_EVENTS_INLINE & REGPARM_MODULE) +# define REGPARM_SIM_EVENTS REGPARM +#else +# define REGPARM_SIM_EVENTS +#endif + +#if ((H_REVEALS_MODULE_P (SIM_EVENTS_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SIM_EVENTS_C) \ + && (REVEAL_MODULE_P (SIM_EVENTS_INLINE))) +# if (SIM_EVENTS_INLINE & INLINE_GLOBALS) +# define INLINE_SIM_EVENTS(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SIM_EVENTS_P 0 +# else +# define INLINE_SIM_EVENTS(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS +# define EXTERN_SIM_EVENTS_P 0 +# endif +#else +# define INLINE_SIM_EVENTS(TYPE) TYPE REGPARM_SIM_EVENTS +# define EXTERN_SIM_EVENTS_P 1 +#endif + +#if (SIM_EVENTS_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SIM_EVENTS(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SIM_EVENTS(TYPE) static TYPE REGPARM_SIM_EVENTS +#endif + +#define STATIC_SIM_EVENTS(TYPE) static TYPE + + + +/* sim-fpu */ + +#if !defined (SIM_FPU_INLINE) && (DEFAULT_INLINE) +# define SIM_FPU_INLINE ALL_C_INLINE +#endif + +#if (SIM_FPU_INLINE & REGPARM_MODULE) +# define REGPARM_SIM_FPU REGPARM +#else +# define REGPARM_SIM_FPU +#endif + +#if ((H_REVEALS_MODULE_P (SIM_FPU_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SIM_FPU_C) \ + && (REVEAL_MODULE_P (SIM_FPU_INLINE))) +# if (SIM_FPU_INLINE & INLINE_GLOBALS) +# define INLINE_SIM_FPU(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SIM_FPU_P 0 +# else +# define INLINE_SIM_FPU(TYPE) static TYPE UNUSED REGPARM_SIM_FPU +# define EXTERN_SIM_FPU_P 0 +# endif +#else +# define INLINE_SIM_FPU(TYPE) TYPE REGPARM_SIM_FPU +# define EXTERN_SIM_FPU_P 1 +#endif + +#if (SIM_FPU_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SIM_FPU(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SIM_FPU(TYPE) static TYPE REGPARM_SIM_FPU +#endif + +#define STATIC_SIM_FPU(TYPE) static TYPE + + + +/* sim-types */ + +#if (SIM_TYPES_INLINE & REGPARM_MODULE) +# define REGPARM_SIM_TYPES REGPARM +#else +# define REGPARM_SIM_TYPES +#endif + +#if ((H_REVEALS_MODULE_P (SIM_TYPES_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SIM_TYPES_C) \ + && (REVEAL_MODULE_P (SIM_TYPES_INLINE))) +# if (SIM_TYPES_INLINE & INLINE_GLOBALS) +# define INLINE_SIM_TYPES(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SIM_TYPES_P 0 +# else +# define INLINE_SIM_TYPES(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES +# define EXTERN_SIM_TYPES_P 0 +# endif +#else +# define INLINE_SIM_TYPES(TYPE) TYPE REGPARM_SIM_TYPES +# define EXTERN_SIM_TYPES_P 1 +#endif + +#if (SIM_TYPES_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SIM_TYPES(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SIM_TYPES(TYPE) static TYPE REGPARM_SIM_TYPES +#endif + +#define STATIC_SIM_TYPES(TYPE) static TYPE + + + +/* sim_main */ + +#if !defined (SIM_MAIN_INLINE) && (DEFAULT_INLINE) +# define SIM_MAIN_INLINE (ALL_C_INLINE) +#endif + +#if (SIM_MAIN_INLINE & REGPARM_MODULE) +# define REGPARM_SIM_MAIN REGPARM +#else +# define REGPARM_SIM_MAIN +#endif + +#if ((H_REVEALS_MODULE_P (SIM_MAIN_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SIM_MAIN_C) \ + && (REVEAL_MODULE_P (SIM_MAIN_INLINE))) +# if (SIM_MAIN_INLINE & INLINE_GLOBALS) +# define INLINE_SIM_MAIN(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SIM_MAIN_P 0 +# else +# define INLINE_SIM_MAIN(TYPE) static TYPE UNUSED REGPARM_SIM_MAIN +# define EXTERN_SIM_MAIN_P 0 +# endif +#else +# define INLINE_SIM_MAIN(TYPE) TYPE REGPARM_SIM_MAIN +# define EXTERN_SIM_MAIN_P 1 +#endif + +#if (SIM_MAIN_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SIM_MAIN(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SIM_MAIN(TYPE) static TYPE REGPARM_SIM_MAIN +#endif + +#define STATIC_SIM_MAIN(TYPE) static TYPE + +/* engine */ + +#if (ENGINE_INLINE & REGPARM_MODULE) +# define REGPARM_ENGINE REGPARM +#else +# define REGPARM_ENGINE +#endif + +#if ((H_REVEALS_MODULE_P (ENGINE_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (ENGINE_C) \ + && (REVEAL_MODULE_P (ENGINE_INLINE))) +# if (ENGINE_INLINE & INLINE_GLOBALS) +# define INLINE_ENGINE(TYPE) static INLINE TYPE UNUSED +# define EXTERN_ENGINE_P 0 +# else +# define INLINE_ENGINE(TYPE) static TYPE UNUSED REGPARM_ENGINE +# define EXTERN_ENGINE_P 0 +# endif +#else +# define INLINE_ENGINE(TYPE) TYPE REGPARM_ENGINE +# define EXTERN_ENGINE_P 1 +#endif + +#if (ENGINE_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_ENGINE(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_ENGINE(TYPE) static TYPE REGPARM_ENGINE +#endif + +#define STATIC_ENGINE(TYPE) static TYPE + + + +/* icache */ + +#if (ICACHE_INLINE & REGPARM_MODULE) +# define REGPARM_ICACHE REGPARM +#else +# define REGPARM_ICACHE +#endif + +#if ((H_REVEALS_MODULE_P (ICACHE_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (ICACHE_C) \ + && (REVEAL_MODULE_P (ICACHE_INLINE))) +# if (ICACHE_INLINE & INLINE_GLOBALS) +# define INLINE_ICACHE(TYPE) static INLINE TYPE UNUSED +# define EXTERN_ICACHE_P 0 +#else +# define INLINE_ICACHE(TYPE) static TYPE UNUSED REGPARM_ICACHE +# define EXTERN_ICACHE_P 0 +#endif +#else +# define INLINE_ICACHE(TYPE) TYPE REGPARM_ICACHE +# define EXTERN_ICACHE_P 1 +#endif + +#if (ICACHE_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_ICACHE(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_ICACHE(TYPE) static TYPE REGPARM_ICACHE +#endif + +#define STATIC_ICACHE(TYPE) static TYPE + + + +/* idecode */ + +#if (IDECODE_INLINE & REGPARM_MODULE) +# define REGPARM_IDECODE REGPARM +#else +# define REGPARM_IDECODE +#endif + +#if ((H_REVEALS_MODULE_P (IDECODE_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (IDECODE_C) \ + && (REVEAL_MODULE_P (IDECODE_INLINE))) +# if (IDECODE_INLINE & INLINE_GLOBALS) +# define INLINE_IDECODE(TYPE) static INLINE TYPE UNUSED +# define EXTERN_IDECODE_P 0 +#else +# define INLINE_IDECODE(TYPE) static TYPE UNUSED REGPARM_IDECODE +# define EXTERN_IDECODE_P 0 +#endif +#else +# define INLINE_IDECODE(TYPE) TYPE REGPARM_IDECODE +# define EXTERN_IDECODE_P 1 +#endif + +#if (IDECODE_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_IDECODE(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_IDECODE(TYPE) static TYPE REGPARM_IDECODE +#endif + +#define STATIC_IDECODE(TYPE) static TYPE + + + +/* semantics */ + +#if (SEMANTICS_INLINE & REGPARM_MODULE) +# define REGPARM_SEMANTICS REGPARM +#else +# define REGPARM_SEMANTICS +#endif + +#if ((H_REVEALS_MODULE_P (SEMANTICS_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SEMANTICS_C) \ + && (REVEAL_MODULE_P (SEMANTICS_INLINE))) +# if (SEMANTICS_INLINE & INLINE_GLOBALS) +# define INLINE_SEMANTICS(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SEMANTICS_P 0 +#else +# define INLINE_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS +# define EXTERN_SEMANTICS_P 0 +#endif +#else +# define INLINE_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS +# define EXTERN_SEMANTICS_P 1 +#endif + +#if EXTERN_SEMANTICS_P +# define EXTERN_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS +#else +# define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS +#endif + +#if (SEMANTICS_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SEMANTICS(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SEMANTICS(TYPE) static TYPE REGPARM_SEMANTICS +#endif + +#define STATIC_SEMANTICS(TYPE) static TYPE + + + +/* support */ + +#if !defined (SUPPORT_INLINE) && (DEFAULT_INLINE) +# define SUPPORT_INLINE ALL_C_INLINE +#endif + +#if (SUPPORT_INLINE & REGPARM_MODULE) +# define REGPARM_SUPPORT REGPARM +#else +# define REGPARM_SUPPORT +#endif + +#if ((H_REVEALS_MODULE_P (SUPPORT_INLINE) || defined (SIM_INLINE_C)) \ + && !defined (SUPPORT_C) \ + && (REVEAL_MODULE_P (SUPPORT_INLINE))) +# if (SUPPORT_INLINE & INLINE_GLOBALS) +# define INLINE_SUPPORT(TYPE) static INLINE TYPE UNUSED +# define EXTERN_SUPPORT_P 0 +#else +# define INLINE_SUPPORT(TYPE) static TYPE UNUSED REGPARM_SUPPORT +# define EXTERN_SUPPORT_P 0 +#endif +#else +# define INLINE_SUPPORT(TYPE) TYPE REGPARM_SUPPORT +# define EXTERN_SUPPORT_P 1 +#endif + +#if (SUPPORT_INLINE & INLINE_LOCALS) +# define STATIC_INLINE_SUPPORT(TYPE) static INLINE TYPE +#else +# define STATIC_INLINE_SUPPORT(TYPE) static TYPE REGPARM_SUPPORT +#endif + +#define STATIC_SUPPORT(TYPE) static TYPE + + + +#endif |