sim/common/sim-inline.h

   1 /* The common simulator framework for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2016 Free Software Foundation, Inc.
   4
   5    Contributed by Andrew Cagney and Red Hat.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #ifndef SIM_INLINE_H
  24 #define SIM_INLINE_H
  25
  26
  27 /* INLINE CODE SELECTION:
  28
  29    GCC -O3 attempts to inline any function or procedure in scope.  The
  30    options below facilitate finer grained control over what is and
  31    what is not inlined.  In particular, it allows the selection of
  32    modules for inlining.  Doing this allows the compiler to both
  33    eliminate the overhead of function calls and (as a consequence)
  34    also eliminate further dead code.
  35
  36    On a CISC (x86) I've found that I can achieve an order of magnitude
  37    speed improvement (x3-x5).  In the case of RISC (sparc) while the
  38    performance gain isn't as great it is still significant.
  39
  40    Each module is controled by the macro <module>_INLINE which can
  41    have the values described below
  42
  43        0 (ZERO)
  44
  45          Do not inline any thing for the given module
  46
  47    The following bit fields values can be combined:
  48
  49       H_REVEALS_MODULE:
  50       C_REVEALS_MODULE:
  51
  52          Include the C file for the module into the file being
  53          compiled.  The actual inlining is controlled separatly.
  54
  55          While of no apparent benefit, this makes it possible for the
  56          included module, when compiled, to inline its calls to what
  57          would otherwize be external functions.
  58
  59          {C_,H_} Determines where the module is inlined.  A
  60          H_REVEALS_MODULE will be included everywhere.
  61
  62       INLINE_GLOBALS:
  63
  64          Make external functions within the module `inline'.  Thus if
  65          the module is included into a file being compiled, calls to
  66          the included modules funtions can be eliminated.  INLINE_MODULE
  67          implies REVEAL_MODULE.
  68
  69       INLINE_LOCALS:
  70
  71          Make internal (static) functions within the module `inline'.
  72
  73
  74    CODING STYLE:
  75
  76    The inline ability is enabled by specifying every data and function
  77    declaration and definition using one of the following methods:
  78
  79
  80        GLOBAL INLINE FUNCTIONS:
  81
  82           Such functions are small and used heavily.  Inlining them
  83           will eliminate an unnecessary function call overhead.
  84
  85           .h: INLINE_OURPKG (void) ourpkg_func
  86               (int x,
  87                int y);
  88
  89           .c: INLINE_OURPKG (void)
  90               ourpkg_func (int x,
  91                            int y)
  92               {
  93                 ...
  94               }
  95
  96
  97        GLOBAL INLINE VARIABLES:
  98
  99           This doesn't make much sense.
 100
 101
 102        GLOBAL NON-INLINE (EXTERN) FUNCTIONS AND VARIABLES:
 103
 104           These include functions with varargs parameters.  It can
 105           also include large rarely used functions that contribute
 106           little when inlined.
 107
 108           .h: extern int ourpkg_print
 109               (char *fmt, ...);
 110               extern int a_global_variable;
 111
 112           .c: #if EXTERN_OURPKG_P
 113               int
 114               ourpkg_print (char *fmt,
 115                             ...)
 116               {
 117                  ...
 118               }
 119               #endif
 120               #if EXTERN_OURPKG_P
 121               int a_global_variable = 1;
 122               #endif
 123
 124
 125        LOCAL (STATIC) FUNCTIONS:
 126
 127           These can either be marked inline or just static static vis:
 128
 129           .h: STATIC_INLINE_OURPKG (int) ourpkg_staticf (void);
 130           .c: STATIC_INLINE_OURPKG (int)
 131               ourpkg_staticf (void)
 132               {
 133                 ..
 134               }
 135
 136           .h: STATIC_OURPKG (int) ourpkg_staticf (void);
 137           .c: STATIC_OURPKG (int)
 138               ourpkg_staticf (void)
 139               {
 140                 ..
 141               }
 142
 143
 144        All .h files:
 145
 146
 147           All modules must wrap their .h code in the following:
 148
 149           #ifndef OURPKG_H
 150           #define OURPKG_H
 151           ... code proper ...
 152           #endif
 153
 154           In addition, modules that want to allow global inlining must
 155           include the lines (below) at the end of the .h file. (FIXME:
 156           Shouldn't be needed).
 157
 158           #if H_REVEALS_MODULE_P (OURPKG_INLINE)
 159           #include "ourpkg.c"
 160           #endif
 161
 162
 163        All .c files:
 164
 165           All modules must wrap their .c code in the following
 166
 167           #ifndef OURPKG_C
 168           #define OURPKG_C
 169           ... code proper ...
 170           #endif
 171
 172
 173    NOW IT WORKS:
 174
 175       0:
 176
 177       Since no inlining is defined. All macro's get standard defaults
 178       (extern, static, ...).
 179
 180
 181
 182       H_REVEALS_MODULE (alt includes our):
 183
 184
 185       altprog.c defines ALTPROG_C and then includes sim-inline.h.
 186
 187       In sim-inline.h the expression `` H_REVEALS_MODULE_P
 188       (OURPROG_INLINE) && !  defined (OURPROG_C) && REVEAL_MODULE_P
 189       (OURPROG_INLINE) '' is TRUE so it defines *_OURPROG as static
 190       and EXTERN_OURPROG_P as FALSE.
 191
 192       altprog.c includes ourprog.h.
 193
 194       In ourprog.h the expression ``H_REVEALS_MODULE_P
 195       (OURPROG_INLINE)'' is TRUE so it includes ourprog.c.
 196
 197       Consequently, all the code in ourprog.c is visible and static in
 198       the file altprog.c
 199
 200
 201
 202       H_REVEALS_MODULE (our includes our):
 203
 204
 205       ourprog.c defines OURPROG_C and then includes sim-inline.h.
 206
 207       In sim-inline.h the term `` ! defined (OURPROG_C) '' is FALSE so
 208       it defines *_OURPROG as non-static and EXTERN_OURPROG_P as TRUE.
 209
 210       ourprog.c includes ourprog.h.
 211
 212       In ourprog.h the expression ``H_REVEALS_MODULE_P
 213       (OURPROG_INLINE)'' is true so it includes ourprog.c.
 214
 215       In ourprog.c (second include) the expression defined (OURPROG_C)
 216       and so the body is not re-included.
 217
 218       Consequently, ourprog.o will contain a non-static copy of all
 219       the exported symbols.
 220
 221
 222
 223       C_REVEALS_MODULE (alt includes our):
 224
 225
 226       altprog.c defines ALTPROG_C and then includes sim-inline.c
 227
 228       sim-inline.c defines C_INLINE_C and then includes sim-inline.h
 229
 230       In sim-inline.h the expression `` defined (SIM_INLINE) && !
 231       defined (OURPROG_C) && REVEAL_MODULE_P (OURPROG_INLINE) '' is
 232       true so it defines *_OURPROG as static and EXTERN_OURPROG_P as
 233       FALSE.
 234
 235       In sim-inline.c the expression ``C_REVEALS_MODULE_P
 236       (OURPROG_INLINE)'' is true so it includes ourprog.c.
 237
 238       Consequently, all the code in ourprog.c is visible and static in
 239       the file altprog.c.
 240
 241
 242
 243       C_REVEALS_MODULE (our includes our):
 244
 245
 246       ourprog.c defines OURPROG_C and then includes sim-inline.c
 247
 248       sim-inline.c defines C_INLINE_C and then includes sim-inline.h
 249
 250       In sim-inline.h the term `` !  defined (OURPROG_C) '' is FALSE
 251       so it defines *_OURPROG as non-static and EXTERN_OURPROG_P as
 252       TRUE.
 253
 254       Consequently, ourprog.o will contain a non-static copy of all
 255       the exported symbols.
 256
 257
 258
 259    REALITY CHECK:
 260
 261    This is not for the faint hearted.  I've seen GCC get up to 500mb
 262    trying to compile what this can create. */
 263 \f
 264 #define H_REVEALS_MODULE                1
 265 #define C_REVEALS_MODULE                2
 266 #define INLINE_GLOBALS                  4
 267 #define INLINE_LOCALS                   8
 268
 269 #define REGPARM_MODULE                 32
 270
 271 #define ALL_H_INLINE (H_REVEALS_MODULE | INLINE_GLOBALS | INLINE_LOCALS)
 272 #define ALL_C_INLINE (C_REVEALS_MODULE | INLINE_GLOBALS | INLINE_LOCALS)
 273
 274
 275 /* Default macro to simplify control several of key the inlines */
 276
 277 #ifndef DEFAULT_INLINE
 278 #define DEFAULT_INLINE                  INLINE_LOCALS
 279 #endif
 280
 281 #define REVEAL_MODULE_P(X) (X & (H_REVEALS_MODULE | C_REVEALS_MODULE))
 282 #define H_REVEALS_MODULE_P(X) ((X & H_REVEALS_MODULE))
 283 #define C_REVEALS_MODULE_P(X) ((X & C_REVEALS_MODULE))
 284
 285
 286 #ifndef HAVE_INLINE
 287 #ifdef __GNUC__
 288 #define HAVE_INLINE
 289 #endif
 290 #endif
 291
 292
 293 /* Your compilers inline prefix */
 294
 295 #ifndef INLINE
 296 #if defined (__GNUC__) && defined (__OPTIMIZE__)
 297 #define INLINE __inline__
 298 #else
 299 #define INLINE /*inline*/
 300 #endif
 301 #endif
 302
 303 /* ??? Temporary, pending decision to always use extern inline and do a vast
 304    cleanup of inline support.  */
 305 #ifndef INLINE2
 306 #if defined (__GNUC_GNU_INLINE__) || defined (__GNUC_STDC_INLINE__)
 307 #define INLINE2 __inline__ __attribute__ ((__gnu_inline__))
 308 #elif defined (__GNUC__)
 309 #define INLINE2 __inline__
 310 #else
 311 #define INLINE2 /*inline*/
 312 #endif
 313 #endif
 314
 315
 316 /* Your compiler's static inline prefix */
 317
 318 #ifndef STATIC_INLINE
 319 #define STATIC_INLINE static INLINE
 320 #endif
 321
 322
 323 /* Your compiler's extern inline prefix */
 324
 325 #ifndef EXTERN_INLINE
 326 #define EXTERN_INLINE extern INLINE2
 327 #endif
 328
 329
 330 /* Your compiler's no-return reserved word */
 331
 332 #ifndef NORETURN
 333 #define NORETURN
 334 #endif
 335
 336
 337
 338 /* Your compilers's unused reserved word */
 339
 340 #if !defined (UNUSED)
 341 #if (!defined (__GNUC__) \
 342      || (__GNUC__ < 2) \
 343      || (__GNUC__ == 2 && __GNUC_MINOR__ < 7))
 344 #define UNUSED
 345 #else
 346 #define UNUSED __attribute__((__unused__))
 347 #endif
 348 #endif
 349
 350
 351
 352
 353 /* Your compilers nonstandard function call mechanism prefix */
 354
 355 #if !defined REGPARM
 356 #if defined (__GNUC__) && (defined (__i386__) || defined (__i486__) || defined (__i586__) || defined (__i686__))
 357 #if (WITH_REGPARM && WITH_STDCALL)
 358 #define REGPARM __attribute__((__regparm__(WITH_REGPARM),__stdcall__))
 359 #else
 360 #if (WITH_REGPARM && !WITH_STDCALL)
 361 #define REGPARM __attribute__((__regparm__(WITH_REGPARM)))
 362 #else
 363 #if (!WITH_REGPARM && WITH_STDCALL)
 364 #define REGPARM __attribute__((__stdcall__))
 365 #endif
 366 #endif
 367 #endif
 368 #endif
 369 #endif
 370
 371 #if !defined REGPARM
 372 #define REGPARM
 373 #endif
 374
 375
 376 \f
 377 /* *****
 378    sim-bits and sim-endian are treated differently from the rest
 379    of the modules below.  Their default value is ALL_H_INLINE.
 380    The rest are ALL_C_INLINE.  Don't blink, you'll miss it!
 381    *****
 382    */
 383
 384 /* sim-bits */
 385
 386 #if !defined (SIM_BITS_INLINE) && (DEFAULT_INLINE)
 387 # define SIM_BITS_INLINE (ALL_H_INLINE)
 388 #endif
 389
 390 #if (SIM_BITS_INLINE & REGPARM_MODULE)
 391 # define REGPARM_SIM_BITS REGPARM
 392 #else
 393 # define REGPARM_SIM_BITS
 394 #endif
 395
 396 #if ((H_REVEALS_MODULE_P (SIM_BITS_INLINE) || defined (SIM_INLINE_C)) \
 397      && !defined (SIM_BITS_C) \
 398      && (REVEAL_MODULE_P (SIM_BITS_INLINE)))
 399 # if (SIM_BITS_INLINE & INLINE_GLOBALS)
 400 #  define INLINE_SIM_BITS(TYPE) static INLINE TYPE UNUSED
 401 #  define EXTERN_SIM_BITS_P 0
 402 # else
 403 #  define INLINE_SIM_BITS(TYPE) static TYPE UNUSED REGPARM_SIM_BITS
 404 #  define EXTERN_SIM_BITS_P 0
 405 # endif
 406 #else
 407 # define INLINE_SIM_BITS(TYPE) TYPE REGPARM_SIM_BITS
 408 # define EXTERN_SIM_BITS_P 1
 409 #endif
 410
 411 #if (SIM_BITS_INLINE & INLINE_LOCALS)
 412 # define STATIC_INLINE_SIM_BITS(TYPE) static INLINE TYPE
 413 #else
 414 # define STATIC_INLINE_SIM_BITS(TYPE) static TYPE REGPARM_SIM_BITS
 415 #endif
 416
 417 #define STATIC_SIM_BITS(TYPE) static TYPE
 418
 419
 420
 421 /* sim-core */
 422
 423 #if !defined (SIM_CORE_INLINE) && (DEFAULT_INLINE)
 424 # define SIM_CORE_INLINE ALL_C_INLINE
 425 #endif
 426
 427 #if (SIM_CORE_INLINE & REGPARM_MODULE)
 428 # define REGPARM_SIM_CORE REGPARM
 429 #else
 430 # define REGPARM_SIM_CORE
 431 #endif
 432
 433 #if ((H_REVEALS_MODULE_P (SIM_CORE_INLINE) || defined (SIM_INLINE_C)) \
 434      && !defined (SIM_CORE_C) \
 435      && (REVEAL_MODULE_P (SIM_CORE_INLINE)))
 436 # if (SIM_CORE_INLINE & INLINE_GLOBALS)
 437 #  define INLINE_SIM_CORE(TYPE) static INLINE TYPE UNUSED
 438 #  define EXTERN_SIM_CORE_P 0
 439 #else
 440 #  define INLINE_SIM_CORE(TYPE) static TYPE UNUSED REGPARM_SIM_CORE
 441 #  define EXTERN_SIM_CORE_P 0
 442 #endif
 443 #else
 444 # define INLINE_SIM_CORE(TYPE) TYPE REGPARM_SIM_CORE
 445 # define EXTERN_SIM_CORE_P 1
 446 #endif
 447
 448 #if (SIM_CORE_INLINE & INLINE_LOCALS)
 449 # define STATIC_INLINE_SIM_CORE(TYPE) static INLINE TYPE
 450 #else
 451 # define STATIC_INLINE_SIM_CORE(TYPE) static TYPE REGPARM_SIM_CORE
 452 #endif
 453
 454 #define STATIC_SIM_CORE(TYPE) static TYPE
 455
 456
 457
 458 /* sim-endian */
 459
 460 #if !defined (SIM_ENDIAN_INLINE) && (DEFAULT_INLINE)
 461 # define SIM_ENDIAN_INLINE ALL_H_INLINE
 462 #endif
 463
 464 #if (SIM_ENDIAN_INLINE & REGPARM_MODULE)
 465 # define REGPARM_SIM_ENDIAN REGPARM
 466 #else
 467 # define REGPARM_SIM_ENDIAN
 468 #endif
 469
 470 #if ((H_REVEALS_MODULE_P (SIM_ENDIAN_INLINE) || defined (SIM_INLINE_C)) \
 471      && !defined (SIM_ENDIAN_C) \
 472      && (REVEAL_MODULE_P (SIM_ENDIAN_INLINE)))
 473 # if (SIM_ENDIAN_INLINE & INLINE_GLOBALS)
 474 #  define INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE UNUSED
 475 #  define EXTERN_SIM_ENDIAN_P 0
 476 # else
 477 #  define INLINE_SIM_ENDIAN(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN
 478 #  define EXTERN_SIM_ENDIAN_P 0
 479 # endif
 480 #else
 481 # define INLINE_SIM_ENDIAN(TYPE) TYPE REGPARM_SIM_ENDIAN
 482 # define EXTERN_SIM_ENDIAN_P 1
 483 #endif
 484
 485 #if (SIM_ENDIAN_INLINE & INLINE_LOCALS)
 486 # define STATIC_INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE
 487 #else
 488 # define STATIC_INLINE_SIM_ENDIAN(TYPE) static TYPE REGPARM_SIM_ENDIAN
 489 #endif
 490
 491 #define STATIC_SIM_ENDIAN(TYPE) static TYPE
 492
 493
 494
 495 /* sim-events */
 496
 497 #if !defined (SIM_EVENTS_INLINE) && (DEFAULT_INLINE)
 498 # define SIM_EVENTS_INLINE ALL_C_INLINE
 499 #endif
 500
 501 #if (SIM_EVENTS_INLINE & REGPARM_MODULE)
 502 # define REGPARM_SIM_EVENTS REGPARM
 503 #else
 504 # define REGPARM_SIM_EVENTS
 505 #endif
 506
 507 #if ((H_REVEALS_MODULE_P (SIM_EVENTS_INLINE) || defined (SIM_INLINE_C)) \
 508      && !defined (SIM_EVENTS_C) \
 509      && (REVEAL_MODULE_P (SIM_EVENTS_INLINE)))
 510 # if (SIM_EVENTS_INLINE & INLINE_GLOBALS)
 511 #  define INLINE_SIM_EVENTS(TYPE) static INLINE TYPE UNUSED
 512 #  define EXTERN_SIM_EVENTS_P 0
 513 # else
 514 #  define INLINE_SIM_EVENTS(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS
 515 #  define EXTERN_SIM_EVENTS_P 0
 516 # endif
 517 #else
 518 # define INLINE_SIM_EVENTS(TYPE) TYPE REGPARM_SIM_EVENTS
 519 # define EXTERN_SIM_EVENTS_P 1
 520 #endif
 521
 522 #if (SIM_EVENTS_INLINE & INLINE_LOCALS)
 523 # define STATIC_INLINE_SIM_EVENTS(TYPE) static INLINE TYPE
 524 #else
 525 # define STATIC_INLINE_SIM_EVENTS(TYPE) static TYPE REGPARM_SIM_EVENTS
 526 #endif
 527
 528 #define STATIC_SIM_EVENTS(TYPE) static TYPE
 529
 530
 531
 532 /* sim-fpu */
 533
 534 #if !defined (SIM_FPU_INLINE) && (DEFAULT_INLINE)
 535 # define SIM_FPU_INLINE ALL_C_INLINE
 536 #endif
 537
 538 #if (SIM_FPU_INLINE & REGPARM_MODULE)
 539 # define REGPARM_SIM_FPU REGPARM
 540 #else
 541 # define REGPARM_SIM_FPU
 542 #endif
 543
 544 #if ((H_REVEALS_MODULE_P (SIM_FPU_INLINE) || defined (SIM_INLINE_C)) \
 545      && !defined (SIM_FPU_C) \
 546      && (REVEAL_MODULE_P (SIM_FPU_INLINE)))
 547 # if (SIM_FPU_INLINE & INLINE_GLOBALS)
 548 #  define INLINE_SIM_FPU(TYPE) static INLINE TYPE UNUSED
 549 #  define EXTERN_SIM_FPU_P 0
 550 # else
 551 #  define INLINE_SIM_FPU(TYPE) static TYPE UNUSED REGPARM_SIM_FPU
 552 #  define EXTERN_SIM_FPU_P 0
 553 # endif
 554 #else
 555 # define INLINE_SIM_FPU(TYPE) TYPE REGPARM_SIM_FPU
 556 # define EXTERN_SIM_FPU_P 1
 557 #endif
 558
 559 #if (SIM_FPU_INLINE & INLINE_LOCALS)
 560 # define STATIC_INLINE_SIM_FPU(TYPE) static INLINE TYPE
 561 #else
 562 # define STATIC_INLINE_SIM_FPU(TYPE) static TYPE REGPARM_SIM_FPU
 563 #endif
 564
 565 #define STATIC_SIM_FPU(TYPE) static TYPE
 566
 567
 568
 569 /* sim-types */
 570
 571 #if (SIM_TYPES_INLINE & REGPARM_MODULE)
 572 # define REGPARM_SIM_TYPES REGPARM
 573 #else
 574 # define REGPARM_SIM_TYPES
 575 #endif
 576
 577 #if ((H_REVEALS_MODULE_P (SIM_TYPES_INLINE) || defined (SIM_INLINE_C)) \
 578      && !defined (SIM_TYPES_C) \
 579      && (REVEAL_MODULE_P (SIM_TYPES_INLINE)))
 580 # if (SIM_TYPES_INLINE & INLINE_GLOBALS)
 581 #  define INLINE_SIM_TYPES(TYPE) static INLINE TYPE UNUSED
 582 #  define EXTERN_SIM_TYPES_P 0
 583 # else
 584 #  define INLINE_SIM_TYPES(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES
 585 #  define EXTERN_SIM_TYPES_P 0
 586 # endif
 587 #else
 588 # define INLINE_SIM_TYPES(TYPE) TYPE REGPARM_SIM_TYPES
 589 # define EXTERN_SIM_TYPES_P 1
 590 #endif
 591
 592 #if (SIM_TYPES_INLINE & INLINE_LOCALS)
 593 # define STATIC_INLINE_SIM_TYPES(TYPE) static INLINE TYPE
 594 #else
 595 # define STATIC_INLINE_SIM_TYPES(TYPE) static TYPE REGPARM_SIM_TYPES
 596 #endif
 597
 598 #define STATIC_SIM_TYPES(TYPE) static TYPE
 599
 600
 601
 602 /* sim_main */
 603
 604 #if !defined (SIM_MAIN_INLINE) && (DEFAULT_INLINE)
 605 # define SIM_MAIN_INLINE (ALL_C_INLINE)
 606 #endif
 607
 608 #if (SIM_MAIN_INLINE & REGPARM_MODULE)
 609 # define REGPARM_SIM_MAIN REGPARM
 610 #else
 611 # define REGPARM_SIM_MAIN
 612 #endif
 613
 614 #if ((H_REVEALS_MODULE_P (SIM_MAIN_INLINE) || defined (SIM_INLINE_C)) \
 615      && !defined (SIM_MAIN_C) \
 616      && (REVEAL_MODULE_P (SIM_MAIN_INLINE)))
 617 # if (SIM_MAIN_INLINE & INLINE_GLOBALS)
 618 #  define INLINE_SIM_MAIN(TYPE) static INLINE TYPE UNUSED
 619 #  define EXTERN_SIM_MAIN_P 0
 620 # else
 621 #  define INLINE_SIM_MAIN(TYPE) static TYPE UNUSED REGPARM_SIM_MAIN
 622 #  define EXTERN_SIM_MAIN_P 0
 623 # endif
 624 #else
 625 # define INLINE_SIM_MAIN(TYPE) TYPE REGPARM_SIM_MAIN
 626 # define EXTERN_SIM_MAIN_P 1
 627 #endif
 628
 629 #if (SIM_MAIN_INLINE & INLINE_LOCALS)
 630 # define STATIC_INLINE_SIM_MAIN(TYPE) static INLINE TYPE
 631 #else
 632 # define STATIC_INLINE_SIM_MAIN(TYPE) static TYPE REGPARM_SIM_MAIN
 633 #endif
 634
 635 #define STATIC_SIM_MAIN(TYPE) static TYPE
 636 \f
 637 /* engine */
 638
 639 #if (ENGINE_INLINE & REGPARM_MODULE)
 640 # define REGPARM_ENGINE REGPARM
 641 #else
 642 # define REGPARM_ENGINE
 643 #endif
 644
 645 #if ((H_REVEALS_MODULE_P (ENGINE_INLINE) || defined (SIM_INLINE_C)) \
 646      && !defined (ENGINE_C) \
 647      && (REVEAL_MODULE_P (ENGINE_INLINE)))
 648 # if (ENGINE_INLINE & INLINE_GLOBALS)
 649 #  define INLINE_ENGINE(TYPE) static INLINE TYPE UNUSED
 650 #  define EXTERN_ENGINE_P 0
 651 # else
 652 #  define INLINE_ENGINE(TYPE) static TYPE UNUSED REGPARM_ENGINE
 653 #  define EXTERN_ENGINE_P 0
 654 # endif
 655 #else
 656 # define INLINE_ENGINE(TYPE) TYPE REGPARM_ENGINE
 657 # define EXTERN_ENGINE_P 1
 658 #endif
 659
 660 #if (ENGINE_INLINE & INLINE_LOCALS)
 661 # define STATIC_INLINE_ENGINE(TYPE) static INLINE TYPE
 662 #else
 663 # define STATIC_INLINE_ENGINE(TYPE) static TYPE REGPARM_ENGINE
 664 #endif
 665
 666 #define STATIC_ENGINE(TYPE) static TYPE
 667
 668
 669
 670 /* icache */
 671
 672 #if (ICACHE_INLINE & REGPARM_MODULE)
 673 # define REGPARM_ICACHE REGPARM
 674 #else
 675 # define REGPARM_ICACHE
 676 #endif
 677
 678 #if ((H_REVEALS_MODULE_P (ICACHE_INLINE) || defined (SIM_INLINE_C)) \
 679      && !defined (ICACHE_C) \
 680      && (REVEAL_MODULE_P (ICACHE_INLINE)))
 681 # if (ICACHE_INLINE & INLINE_GLOBALS)
 682 #  define INLINE_ICACHE(TYPE) static INLINE TYPE UNUSED
 683 #  define EXTERN_ICACHE_P 0
 684 #else
 685 #  define INLINE_ICACHE(TYPE) static TYPE UNUSED REGPARM_ICACHE
 686 #  define EXTERN_ICACHE_P 0
 687 #endif
 688 #else
 689 # define INLINE_ICACHE(TYPE) TYPE REGPARM_ICACHE
 690 # define EXTERN_ICACHE_P 1
 691 #endif
 692
 693 #if (ICACHE_INLINE & INLINE_LOCALS)
 694 # define STATIC_INLINE_ICACHE(TYPE) static INLINE TYPE
 695 #else
 696 # define STATIC_INLINE_ICACHE(TYPE) static TYPE REGPARM_ICACHE
 697 #endif
 698
 699 #define STATIC_ICACHE(TYPE) static TYPE
 700
 701
 702
 703 /* idecode */
 704
 705 #if (IDECODE_INLINE & REGPARM_MODULE)
 706 # define REGPARM_IDECODE REGPARM
 707 #else
 708 # define REGPARM_IDECODE
 709 #endif
 710
 711 #if ((H_REVEALS_MODULE_P (IDECODE_INLINE) || defined (SIM_INLINE_C)) \
 712      && !defined (IDECODE_C) \
 713      && (REVEAL_MODULE_P (IDECODE_INLINE)))
 714 # if (IDECODE_INLINE & INLINE_GLOBALS)
 715 #  define INLINE_IDECODE(TYPE) static INLINE TYPE UNUSED
 716 #  define EXTERN_IDECODE_P 0
 717 #else
 718 #  define INLINE_IDECODE(TYPE) static TYPE UNUSED REGPARM_IDECODE
 719 #  define EXTERN_IDECODE_P 0
 720 #endif
 721 #else
 722 # define INLINE_IDECODE(TYPE) TYPE REGPARM_IDECODE
 723 # define EXTERN_IDECODE_P 1
 724 #endif
 725
 726 #if (IDECODE_INLINE & INLINE_LOCALS)
 727 # define STATIC_INLINE_IDECODE(TYPE) static INLINE TYPE
 728 #else
 729 # define STATIC_INLINE_IDECODE(TYPE) static TYPE REGPARM_IDECODE
 730 #endif
 731
 732 #define STATIC_IDECODE(TYPE) static TYPE
 733
 734
 735
 736 /* semantics */
 737
 738 #if (SEMANTICS_INLINE & REGPARM_MODULE)
 739 # define REGPARM_SEMANTICS REGPARM
 740 #else
 741 # define REGPARM_SEMANTICS
 742 #endif
 743
 744 #if ((H_REVEALS_MODULE_P (SEMANTICS_INLINE) || defined (SIM_INLINE_C)) \
 745      && !defined (SEMANTICS_C) \
 746      && (REVEAL_MODULE_P (SEMANTICS_INLINE)))
 747 # if (SEMANTICS_INLINE & INLINE_GLOBALS)
 748 #  define INLINE_SEMANTICS(TYPE) static INLINE TYPE UNUSED
 749 #  define EXTERN_SEMANTICS_P 0
 750 #else
 751 #  define INLINE_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS
 752 #  define EXTERN_SEMANTICS_P 0
 753 #endif
 754 #else
 755 # define INLINE_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS
 756 # define EXTERN_SEMANTICS_P 1
 757 #endif
 758
 759 #if EXTERN_SEMANTICS_P
 760 # define EXTERN_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS
 761 #else
 762 # define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS
 763 #endif
 764
 765 #if (SEMANTICS_INLINE & INLINE_LOCALS)
 766 # define STATIC_INLINE_SEMANTICS(TYPE) static INLINE TYPE
 767 #else
 768 # define STATIC_INLINE_SEMANTICS(TYPE) static TYPE REGPARM_SEMANTICS
 769 #endif
 770
 771 #define STATIC_SEMANTICS(TYPE) static TYPE
 772
 773
 774
 775 /* support */
 776
 777 #if !defined (SUPPORT_INLINE) && (DEFAULT_INLINE)
 778 # define SUPPORT_INLINE ALL_C_INLINE
 779 #endif
 780
 781 #if (SUPPORT_INLINE & REGPARM_MODULE)
 782 # define REGPARM_SUPPORT REGPARM
 783 #else
 784 # define REGPARM_SUPPORT
 785 #endif
 786
 787 #if ((H_REVEALS_MODULE_P (SUPPORT_INLINE) || defined (SIM_INLINE_C)) \
 788      && !defined (SUPPORT_C) \
 789      && (REVEAL_MODULE_P (SUPPORT_INLINE)))
 790 # if (SUPPORT_INLINE & INLINE_GLOBALS)
 791 #  define INLINE_SUPPORT(TYPE) static INLINE TYPE UNUSED
 792 #  define EXTERN_SUPPORT_P 0
 793 #else
 794 #  define INLINE_SUPPORT(TYPE) static TYPE UNUSED REGPARM_SUPPORT
 795 #  define EXTERN_SUPPORT_P 0
 796 #endif
 797 #else
 798 # define INLINE_SUPPORT(TYPE) TYPE REGPARM_SUPPORT
 799 # define EXTERN_SUPPORT_P 1
 800 #endif
 801
 802 #if (SUPPORT_INLINE & INLINE_LOCALS)
 803 # define STATIC_INLINE_SUPPORT(TYPE) static INLINE TYPE
 804 #else
 805 # define STATIC_INLINE_SUPPORT(TYPE) static TYPE REGPARM_SUPPORT
 806 #endif
 807
 808 #define STATIC_SUPPORT(TYPE) static TYPE
 809
 810
 811
 812 #endif