-/* This file is part of the program psim.
+/* The common simulator framework for GDB, the GNU Debugger.
- Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
- Copyright (C) 1997, Free Software Foundation, Inc.
+ Copyright 2002-2020 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.
+ Contributed by Andrew Cagney and Red Hat.
- 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.
-
- */
+ This file is part of GDB.
+ 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 3 of the License, or
+ (at your option) any later version.
-#ifndef _SIM_INLINE_H_
-#define _SIM_INLINE_H_
+ 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, see <http://www.gnu.org/licenses/>. */
+
+
+#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 fine grained control over what is and what
- isn't made inline. For instance it can control things down to a
- specific modules static routines. Doing this allows the compiler
- to both eliminate the overhead of function calls and (as a
- consequence) also eliminate further dead code.
+ 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
+ On a CISC (x86) I've found that I can achieve an order of magnitude
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 Do not inline any thing for the given module
+ 0 (ZERO)
+
+ Do not inline any thing for the given module
- The following additional values are `bit fields' and can be
- combined.
+ The following bit fields values can be combined:
- REVEAL_MODULE:
+ H_REVEALS_MODULE:
+ C_REVEALS_MODULE:
- Include the C file for the module into the file being compiled
- but do not make the functions within the module inline.
+ 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
+ included module, when compiled, to inline its calls to what
would otherwize be external functions.
- INLINE_MODULE:
+ {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
- its funtions can be eliminated. 2 implies 1.
+ the included modules funtions can be eliminated. INLINE_MODULE
+ implies REVEAL_MODULE.
INLINE_LOCALS:
Make internal (static) functions within the module `inline'.
- In addition to this, modules have been put into two categories.
- INCLUDED_BY_MODULE
+ CODING STYLE:
- eg sim-endian.h sim-bits.h
+ The inline ability is enabled by specifying every data and function
+ declaration and definition using one of the following methods:
- Because these modules are small and simple and do not have
- any complex interdendencies they are configured, if
- <module>_INLINE is so enabled, to inline themselves in all
- modules that include those files.
- For the default build, this is a real win as all byte
- conversion and bit manipulation functions are inlined.
+ GLOBAL INLINE FUNCTIONS:
- !INCLUDED_BY_MODULE
+ Such functions are small and used heavily. Inlining them
+ will eliminate an unnecessary function call overhead.
- Complex modules - the rest
+ .h: INLINE_OURPKG (void) ourpkg_func
+ (int x,
+ int y);
- These are all handled using the files sim-inline.h and
- sim-inline.c. The main simulator engine includes both of
- these and hence includes all remaining code.
+ .c: INLINE_OURPKG (void)
+ ourpkg_func (int x,
+ int y)
+ {
+ ...
+ }
- The following abreviations are available:
- INCLUDE_MODULE == (REVEAL_MODULE | INLINE_MODULE)
+ GLOBAL INLINE VARIABLES:
- ALL_INLINE == (REVEAL_MODULE | INLINE_MODULE | INLINE_LOCALS)
+ This doesn't make much sense.
- ALL_BY_MODULE = (INCLUDED_BY_MODULE | ALL_INLINE)
- IMPLEMENTATION:
+ GLOBAL NON-INLINE (EXTERN) FUNCTIONS AND VARIABLES:
- The inline ability is enabled by prefixing every data / function
- declaration and definition with one of the following:
+ 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;
- INLINE_<module>
+ .c: #if EXTERN_OURPKG_P
+ int
+ ourpkg_print (char *fmt,
+ ...)
+ {
+ ...
+ }
+ #endif
+ #if EXTERN_OURPKG_P
+ int a_global_variable = 1;
+ #endif
- Prefix to any global function that is a candidate for being
- inline.
- values - `', `static', `static INLINE'
+ LOCAL (STATIC) FUNCTIONS:
+ These can either be marked inline or just static static vis:
- EXTERN_<module>
-
- Prefix to any global data structures for the module. Global
- functions that are not to be inlined shall also be prefixed
- with this.
+ .h: STATIC_INLINE_OURPKG (int) ourpkg_staticf (void);
+ .c: STATIC_INLINE_OURPKG (int)
+ ourpkg_staticf (void)
+ {
+ ..
+ }
- values - `', `static', `static'
+ .h: STATIC_OURPKG (int) ourpkg_staticf (void);
+ .c: STATIC_OURPKG (int)
+ ourpkg_staticf (void)
+ {
+ ..
+ }
- STATIC_INLINE_<module>
+ All .h files:
- Prefix to any local (static) function that is a candidate for
- being made inline.
- values - `static', `static INLINE'
+ All modules must wrap their .h code in the following:
+ #ifndef OURPKG_H
+ #define OURPKG_H
+ ... code proper ...
+ #endif
- static
+ 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).
- Prefix all local data structures. Local functions that are not
- to be inlined shall also be prefixed with this.
+ #if H_REVEALS_MODULE_P (OURPKG_INLINE)
+ #include "ourpkg.c"
+ #endif
- values - `static', `static'
- nb: will not work for modules that are being inlined for every
- use (white lie).
+ All .c files:
+ All modules must wrap their .c code in the following
- extern
- #ifndef _SIM_INLINE_C_
- #endif
-
- Prefix to any declaration of a global object (function or
- variable) that should not be inlined and should have only one
- definition. The #ifndef wrapper goes around the definition
- propper to ensure that only one copy is generated.
+ #ifndef OURPKG_C
+ #define OURPKG_C
+ ... code proper ...
+ #endif
- nb: this will not work when a module is being inlined for every
- use.
+ NOW IT WORKS:
- STATIC_<module>
+ 0:
- Replaced by either `static' or `EXTERN_MODULE'.
+ Since no inlining is defined. All macro's get standard defaults
+ (extern, static, ...).
- REALITY CHECK:
- This is not for the faint hearted. I've seen GCC get up to 500mb
- trying to compile what this can create.
+ H_REVEALS_MODULE (alt includes our):
- Some of the modules do not yet implement the WITH_INLINE_STATIC
- option. Instead they use the macro STATIC_INLINE to control their
- local function.
- Because of the way that GCC parses __attribute__(), the macro's
- need to be adjacent to the functioin name rather then at the start
- of the line vis:
+ altprog.c defines ALTPROG_C and then includes sim-inline.h.
- int STATIC_INLINE_MODULE f(void);
- void INLINE_MODULE *g(void);
+ 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.
-#define REVEAL_MODULE 1
-#define INLINE_MODULE 2
-#define INCLUDE_MODULE (INLINE_MODULE | REVEAL_MODULE)
-#define INLINE_LOCALS 4
-#define ALL_INLINE 7
-#define ALL_BY_MODULE (INCLUDED_BY_MODULE | ALL_INLINE)
-#define INCLUDED_BY_MODULE 16
-#define REGPARM_MODULE 32
+
+ 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. */
+\f
+#define H_REVEALS_MODULE 1
+#define C_REVEALS_MODULE 2
+#define INLINE_GLOBALS 4
+#define INLINE_LOCALS 8
+
+#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 */
#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__)
+#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_GNU_INLINE__) || defined (__GNUC_STDC_INLINE__)
+#define INLINE2 __inline__ __attribute__ ((__gnu_inline__))
+#elif defined (__GNUC__)
+#define INLINE2 __inline__
+#else
+#define INLINE2 /*inline*/
+#endif
+#endif
-/* Your compiler's static prefix */
+/* 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 */
/* Your compilers's unused reserved word */
#if !defined (UNUSED)
-#if (!defined(__GNUC__) \
+#if (!defined (__GNUC__) \
|| (__GNUC__ < 2) \
|| (__GNUC__ == 2 && __GNUC_MINOR__ < 7))
#define UNUSED
+\f
-/* Your compilers nonstandard function call mechanism prefix */
+/* sim_arange */
-#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
+#if !defined (SIM_ARANGE_INLINE) && (DEFAULT_INLINE)
+# define SIM_ARANGE_INLINE (ALL_H_INLINE)
#endif
+
+#if ((H_REVEALS_MODULE_P (SIM_ARANGE_INLINE) || defined (SIM_INLINE_C)) \
+ && !defined (SIM_ARANGE_C) \
+ && (REVEAL_MODULE_P (SIM_ARANGE_INLINE)))
+# if (SIM_ARANGE_INLINE & INLINE_GLOBALS)
+# define INLINE_SIM_ARANGE(TYPE) static INLINE TYPE UNUSED
+# define EXTERN_SIM_ARANGE_P 0
+# else
+# define INLINE_SIM_ARANGE(TYPE) static TYPE UNUSED
+# define EXTERN_SIM_ARANGE_P 0
+# endif
+#else
+# define INLINE_SIM_ARANGE(TYPE) TYPE
+# define EXTERN_SIM_ARANGE_P 1
#endif
-#if !defined REGPARM
-#define REGPARM
+#if (SIM_ARANGE_INLINE & INLINE_LOCALS)
+# define STATIC_INLINE_SIM_ARANGE(TYPE) static INLINE TYPE
+#else
+# define STATIC_INLINE_SIM_ARANGE(TYPE) static TYPE
#endif
+#define STATIC_SIM_ARANGE(TYPE) static TYPE
+
+
+/* *****
+ 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 (SIM_BITS_INLINE & REGPARM_MODULE)
-# define REGPARM_SIM_BITS REGPARM
-#else
-# define REGPARM_SIM_BITS
+#if !defined (SIM_BITS_INLINE) && (DEFAULT_INLINE)
+# define SIM_BITS_INLINE (ALL_H_INLINE)
#endif
-#if (((SIM_BITS_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SIM_BITS_C_) && (SIM_BITS_INLINE & INCLUDE_MODULE))
-# if (SIM_BITS_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_SIM_BITS
+# define EXTERN_SIM_BITS_P 0
# else
-# define INLINE_SIM_BITS(TYPE) static TYPE UNUSED REGPARM_SIM_BITS
-# define EXTERN_SIM_BITS(TYPE) static TYPE UNUSED REGPARM_SIM_BITS
+# define INLINE_SIM_BITS(TYPE) static TYPE UNUSED
+# define EXTERN_SIM_BITS_P 0
# endif
#else
-# define INLINE_SIM_BITS(TYPE) TYPE REGPARM_SIM_BITS
-# define EXTERN_SIM_BITS(TYPE) TYPE REGPARM_SIM_BITS
+# define INLINE_SIM_BITS(TYPE) TYPE
+# 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
+# define STATIC_INLINE_SIM_BITS(TYPE) static TYPE
#endif
+#define STATIC_SIM_BITS(TYPE) static TYPE
+
/* sim-core */
-#if (SIM_CORE_INLINE & REGPARM_MODULE)
-# define REGPARM_SIM_CORE REGPARM
-#else
-# define REGPARM_SIM_CORE
+#if !defined (SIM_CORE_INLINE) && (DEFAULT_INLINE)
+# define SIM_CORE_INLINE ALL_C_INLINE
#endif
-#if (((SIM_CORE_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SIM_CORE_C_) && (SIM_CORE_INLINE & INCLUDE_MODULE))
-# if (SIM_CORE_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_SIM_CORE
+# define EXTERN_SIM_CORE_P 0
#else
-# define INLINE_SIM_CORE(TYPE) static TYPE UNUSED REGPARM_SIM_CORE
-# define EXTERN_SIM_CORE(TYPE) static TYPE UNUSED REGPARM_SIM_CORE
+# define INLINE_SIM_CORE(TYPE) static TYPE UNUSED
+# define EXTERN_SIM_CORE_P 0
#endif
#else
-# define INLINE_SIM_CORE(TYPE) TYPE REGPARM_SIM_CORE
-# define EXTERN_SIM_CORE(TYPE) TYPE REGPARM_SIM_CORE
+# define INLINE_SIM_CORE(TYPE) TYPE
+# 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
+# define STATIC_INLINE_SIM_CORE(TYPE) static TYPE
#endif
+#define STATIC_SIM_CORE(TYPE) static TYPE
+
/* sim-endian */
-#if (SIM_ENDIAN_INLINE & REGPARM_MODULE)
-# define REGPARM_SIM_ENDIAN REGPARM
-#else
-# define REGPARM_SIM_ENDIAN
+#if !defined (SIM_ENDIAN_INLINE) && (DEFAULT_INLINE)
+# define SIM_ENDIAN_INLINE ALL_H_INLINE
#endif
-#if (((SIM_ENDIAN_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SIM_ENDIAN_C_) && (SIM_ENDIAN_INLINE & INCLUDE_MODULE))
-# if (SIM_ENDIAN_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN
+# define EXTERN_SIM_ENDIAN_P 0
# else
-# define INLINE_SIM_ENDIAN(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN
-# define EXTERN_SIM_ENDIAN(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN
+# define INLINE_SIM_ENDIAN(TYPE) static TYPE UNUSED
+# define EXTERN_SIM_ENDIAN_P 0
# endif
#else
-# define INLINE_SIM_ENDIAN(TYPE) TYPE REGPARM_SIM_ENDIAN
-# define EXTERN_SIM_ENDIAN(TYPE) TYPE REGPARM_SIM_ENDIAN
+# define INLINE_SIM_ENDIAN(TYPE) TYPE
+# 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
+# define STATIC_INLINE_SIM_ENDIAN(TYPE) static TYPE
#endif
+#define STATIC_SIM_ENDIAN(TYPE) static TYPE
+
/* sim-events */
-#if (SIM_EVENTS_INLINE & REGPARM_MODULE)
-# define REGPARM_SIM_EVENTS REGPARM
-#else
-# define REGPARM_SIM_EVENTS
+#if !defined (SIM_EVENTS_INLINE) && (DEFAULT_INLINE)
+# define SIM_EVENTS_INLINE ALL_C_INLINE
#endif
-#if (((SIM_EVENTS_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SIM_EVENTS_C_) && (SIM_EVENTS_INLINE & INCLUDE_MODULE))
-# if (SIM_EVENTS_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS
+# define EXTERN_SIM_EVENTS_P 0
# else
-# define INLINE_SIM_EVENTS(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS
-# define EXTERN_SIM_EVENTS(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS
+# define INLINE_SIM_EVENTS(TYPE) static TYPE UNUSED
+# define EXTERN_SIM_EVENTS_P 0
# endif
#else
-# define INLINE_SIM_EVENTS(TYPE) TYPE REGPARM_SIM_EVENTS
-# define EXTERN_SIM_EVENTS(TYPE) TYPE REGPARM_SIM_EVENTS
+# define INLINE_SIM_EVENTS(TYPE) TYPE
+# 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
+# define STATIC_INLINE_SIM_EVENTS(TYPE) static TYPE
#endif
+#define STATIC_SIM_EVENTS(TYPE) static TYPE
+
/* sim-fpu */
-#if (SIM_FPU_INLINE & REGPARM_MODULE)
-# define REGPARM_SIM_FPU REGPARM
-#else
-# define REGPARM_SIM_FPU
+#if !defined (SIM_FPU_INLINE) && (DEFAULT_INLINE)
+# define SIM_FPU_INLINE ALL_C_INLINE
#endif
-#if (((SIM_FPU_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SIM_FPU_C_) && (SIM_FPU_INLINE & INCLUDE_MODULE))
-# if (SIM_FPU_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_SIM_FPU
+# define EXTERN_SIM_FPU_P 0
# else
-# define INLINE_SIM_FPU(TYPE) static TYPE UNUSED REGPARM_SIM_FPU
-# define EXTERN_SIM_FPU(TYPE) static TYPE UNUSED REGPARM_SIM_FPU
+# define INLINE_SIM_FPU(TYPE) static TYPE UNUSED
+# define EXTERN_SIM_FPU_P 0
# endif
#else
-# define INLINE_SIM_FPU(TYPE) TYPE REGPARM_SIM_FPU
-# define EXTERN_SIM_FPU(TYPE) TYPE REGPARM_SIM_FPU
+# define INLINE_SIM_FPU(TYPE) TYPE
+# 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
+# define STATIC_INLINE_SIM_FPU(TYPE) static TYPE
#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
+/* sim-types */
-#if (((SIM_TYPES_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SIM_TYPES_C_) && (SIM_TYPES_INLINE & INCLUDE_MODULE))
-# if (SIM_TYPES_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES
+# define EXTERN_SIM_TYPES_P 0
# else
-# define INLINE_SIM_TYPES(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES
-# define EXTERN_SIM_TYPES(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES
+# define INLINE_SIM_TYPES(TYPE) static TYPE UNUSED
+# define EXTERN_SIM_TYPES_P 0
# endif
#else
-# define INLINE_SIM_TYPES(TYPE) TYPE REGPARM_SIM_TYPES
-# define EXTERN_SIM_TYPES(TYPE) TYPE REGPARM_SIM_TYPES
+# define INLINE_SIM_TYPES(TYPE) TYPE
+# 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
+# define STATIC_INLINE_SIM_TYPES(TYPE) static TYPE
#endif
+#define STATIC_SIM_TYPES(TYPE) static TYPE
-/* icache */
-#if (ICACHE_INLINE & REGPARM_MODULE)
-# define REGPARM_ICACHE REGPARM
+/* sim_main */
+
+#if !defined (SIM_MAIN_INLINE) && (DEFAULT_INLINE)
+# define SIM_MAIN_INLINE (ALL_C_INLINE)
+#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
+# define EXTERN_SIM_MAIN_P 0
+# endif
+#else
+# define INLINE_SIM_MAIN(TYPE) TYPE
+# 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
+#endif
+
+#define STATIC_SIM_MAIN(TYPE) static TYPE
+\f
+/* engine */
+
+#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
+# define EXTERN_ENGINE_P 0
+# endif
+#else
+# define INLINE_ENGINE(TYPE) TYPE
+# define EXTERN_ENGINE_P 1
+#endif
+
+#if (ENGINE_INLINE & INLINE_LOCALS)
+# define STATIC_INLINE_ENGINE(TYPE) static INLINE TYPE
#else
-# define REGPARM_ICACHE
+# define STATIC_INLINE_ENGINE(TYPE) static TYPE
#endif
-#if (((ICACHE_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_ICACHE_C_) && (ICACHE_INLINE & INCLUDE_MODULE))
-# if (ICACHE_INLINE & INLINE_MODULE)
+#define STATIC_ENGINE(TYPE) static TYPE
+
+
+
+/* icache */
+
+#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(TYPE) static TYPE UNUSED REGPARM_ICACHE
+# define EXTERN_ICACHE_P 0
#else
-# define INLINE_ICACHE(TYPE) static TYPE UNUSED REGPARM_ICACHE
-# define EXTERN_ICACHE(TYPE) static TYPE UNUSED REGPARM_ICACHE
+# define INLINE_ICACHE(TYPE) static TYPE UNUSED
+# define EXTERN_ICACHE_P 0
#endif
#else
-# define INLINE_ICACHE(TYPE) TYPE REGPARM_ICACHE
-# define EXTERN_ICACHE(TYPE) TYPE REGPARM_ICACHE
+# define INLINE_ICACHE(TYPE) TYPE
+# 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
+# define STATIC_INLINE_ICACHE(TYPE) static TYPE
#endif
+#define STATIC_ICACHE(TYPE) static TYPE
-/* idecode */
-#if (IDECODE_INLINE & REGPARM_MODULE)
-# define REGPARM_IDECODE REGPARM
-#else
-# define REGPARM_IDECODE
-#endif
+/* idecode */
-#if (((IDECODE_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_IDECODE_C_) && (IDECODE_INLINE & INCLUDE_MODULE))
-# if (IDECODE_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_IDECODE
+# define EXTERN_IDECODE_P 0
#else
-# define INLINE_IDECODE(TYPE) static TYPE UNUSED REGPARM_IDECODE
-# define EXTERN_IDECODE(TYPE) static TYPE UNUSED REGPARM_IDECODE
+# define INLINE_IDECODE(TYPE) static TYPE UNUSED
+# define EXTERN_IDECODE_P 0
#endif
#else
-# define INLINE_IDECODE(TYPE) TYPE REGPARM_IDECODE
-# define EXTERN_IDECODE(TYPE) TYPE REGPARM_IDECODE
+# define INLINE_IDECODE(TYPE) TYPE
+# 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
+# define STATIC_INLINE_IDECODE(TYPE) static TYPE
#endif
+#define STATIC_IDECODE(TYPE) static TYPE
+
/* semantics */
-#if (SEMANTICS_INLINE & REGPARM_MODULE)
-# define REGPARM_SEMANTICS REGPARM
+#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 REGPARM_SEMANTICS
+# define INLINE_SEMANTICS(TYPE) static TYPE UNUSED
+# define EXTERN_SEMANTICS_P 0
#endif
-
-#if (((SEMANTICS_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SEMANTICS_C_) && (SEMANTICS_INLINE & INCLUDE_MODULE))
-# if (SEMANTICS_INLINE & INLINE_MODULE)
-# define INLINE_SEMANTICS(TYPE) static INLINE TYPE UNUSED
-# define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS
#else
-# define INLINE_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS
-# define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS
+# define INLINE_SEMANTICS(TYPE) TYPE
+# define EXTERN_SEMANTICS_P 1
#endif
+
+#if EXTERN_SEMANTICS_P
+# define EXTERN_SEMANTICS(TYPE) TYPE
#else
-# define INLINE_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS
-# define EXTERN_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS
+# define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED
#endif
#if (SEMANTICS_INLINE & INLINE_LOCALS)
# define STATIC_INLINE_SEMANTICS(TYPE) static INLINE TYPE
#else
-# define STATIC_INLINE_SEMANTICS(TYPE) static TYPE REGPARM_SEMANTICS
+# define STATIC_INLINE_SEMANTICS(TYPE) static TYPE
#endif
+#define STATIC_SEMANTICS(TYPE) static TYPE
+
/* support */
-#if (SUPPORT_INLINE & REGPARM_MODULE)
-# define REGPARM_SUPPORT REGPARM
-#else
-# define REGPARM_SUPPORT
+#if !defined (SUPPORT_INLINE) && (DEFAULT_INLINE)
+# define SUPPORT_INLINE ALL_C_INLINE
#endif
-#if (((SUPPORT_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \
- && !defined(_SUPPORT_C_) && (SUPPORT_INLINE & INCLUDE_MODULE))
-# if (SUPPORT_INLINE & INLINE_MODULE)
+#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(TYPE) static TYPE UNUSED REGPARM_SUPPORT
+# define EXTERN_SUPPORT_P 0
#else
-# define INLINE_SUPPORT(TYPE) static TYPE UNUSED REGPARM_SUPPORT
-# define EXTERN_SUPPORT(TYPE) static TYPE UNUSED REGPARM_SUPPORT
+# define INLINE_SUPPORT(TYPE) static TYPE UNUSED
+# define EXTERN_SUPPORT_P 0
#endif
#else
-# define INLINE_SUPPORT(TYPE) TYPE REGPARM_SUPPORT
-# define EXTERN_SUPPORT(TYPE) TYPE REGPARM_SUPPORT
+# define INLINE_SUPPORT(TYPE) TYPE
+# 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
+# define STATIC_INLINE_SUPPORT(TYPE) static TYPE
#endif
+#define STATIC_SUPPORT(TYPE) static TYPE
+
#endif
projects / deliverable / binutils-gdb.git / blobdiff