Initial creation of sourceware repositorygdb-4_18-branchpoint

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