mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-01 14:03:56 +08:00
813 lines
20 KiB
C++
813 lines
20 KiB
C++
/* The common simulator framework for GDB, the GNU Debugger.
|
||
|
||
Copyright 2002-2016 Free Software Foundation, Inc.
|
||
|
||
Contributed by Andrew Cagney and Red Hat.
|
||
|
||
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.
|
||
|
||
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 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 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 (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_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 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
|