sim/common/sim-inline.h

   1 /* The common simulator framework for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2017 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 ALL_H_INLINE (H_REVEALS_MODULE | INLINE_GLOBALS | INLINE_LOCALS)
 270 #define ALL_C_INLINE (C_REVEALS_MODULE | INLINE_GLOBALS | INLINE_LOCALS)
 271
 272
 273 /* Default macro to simplify control several of key the inlines */
 274
 275 #ifndef DEFAULT_INLINE
 276 #define DEFAULT_INLINE                  INLINE_LOCALS
 277 #endif
 278
 279 #define REVEAL_MODULE_P(X) (X & (H_REVEALS_MODULE | C_REVEALS_MODULE))
 280 #define H_REVEALS_MODULE_P(X) ((X & H_REVEALS_MODULE))
 281 #define C_REVEALS_MODULE_P(X) ((X & C_REVEALS_MODULE))
 282
 283
 284 #ifndef HAVE_INLINE
 285 #ifdef __GNUC__
 286 #define HAVE_INLINE
 287 #endif
 288 #endif
 289
 290
 291 /* Your compilers inline prefix */
 292
 293 #ifndef INLINE
 294 #if defined (__GNUC__) && defined (__OPTIMIZE__)
 295 #define INLINE __inline__
 296 #else
 297 #define INLINE /*inline*/
 298 #endif
 299 #endif
 300
 301 /* ??? Temporary, pending decision to always use extern inline and do a vast
 302    cleanup of inline support.  */
 303 #ifndef INLINE2
 304 #if defined (__GNUC_GNU_INLINE__) || defined (__GNUC_STDC_INLINE__)
 305 #define INLINE2 __inline__ __attribute__ ((__gnu_inline__))
 306 #elif defined (__GNUC__)
 307 #define INLINE2 __inline__
 308 #else
 309 #define INLINE2 /*inline*/
 310 #endif
 311 #endif
 312
 313
 314 /* Your compiler's static inline prefix */
 315
 316 #ifndef STATIC_INLINE
 317 #define STATIC_INLINE static INLINE
 318 #endif
 319
 320
 321 /* Your compiler's extern inline prefix */
 322
 323 #ifndef EXTERN_INLINE
 324 #define EXTERN_INLINE extern INLINE2
 325 #endif
 326
 327
 328 /* Your compiler's no-return reserved word */
 329
 330 #ifndef NORETURN
 331 #define NORETURN
 332 #endif
 333
 334
 335
 336 /* Your compilers's unused reserved word */
 337
 338 #if !defined (UNUSED)
 339 #if (!defined (__GNUC__) \
 340      || (__GNUC__ < 2) \
 341      || (__GNUC__ == 2 && __GNUC_MINOR__ < 7))
 342 #define UNUSED
 343 #else
 344 #define UNUSED __attribute__((__unused__))
 345 #endif
 346 #endif
 347
 348
 349
 350 \f
 351 /* *****
 352    sim-bits and sim-endian are treated differently from the rest
 353    of the modules below.  Their default value is ALL_H_INLINE.
 354    The rest are ALL_C_INLINE.  Don't blink, you'll miss it!
 355    *****
 356    */
 357
 358 /* sim-bits */
 359
 360 #if !defined (SIM_BITS_INLINE) && (DEFAULT_INLINE)
 361 # define SIM_BITS_INLINE (ALL_H_INLINE)
 362 #endif
 363
 364 #if ((H_REVEALS_MODULE_P (SIM_BITS_INLINE) || defined (SIM_INLINE_C)) \
 365      && !defined (SIM_BITS_C) \
 366      && (REVEAL_MODULE_P (SIM_BITS_INLINE)))
 367 # if (SIM_BITS_INLINE & INLINE_GLOBALS)
 368 #  define INLINE_SIM_BITS(TYPE) static INLINE TYPE UNUSED
 369 #  define EXTERN_SIM_BITS_P 0
 370 # else
 371 #  define INLINE_SIM_BITS(TYPE) static TYPE UNUSED
 372 #  define EXTERN_SIM_BITS_P 0
 373 # endif
 374 #else
 375 # define INLINE_SIM_BITS(TYPE) TYPE
 376 # define EXTERN_SIM_BITS_P 1
 377 #endif
 378
 379 #if (SIM_BITS_INLINE & INLINE_LOCALS)
 380 # define STATIC_INLINE_SIM_BITS(TYPE) static INLINE TYPE
 381 #else
 382 # define STATIC_INLINE_SIM_BITS(TYPE) static TYPE
 383 #endif
 384
 385 #define STATIC_SIM_BITS(TYPE) static TYPE
 386
 387
 388
 389 /* sim-core */
 390
 391 #if !defined (SIM_CORE_INLINE) && (DEFAULT_INLINE)
 392 # define SIM_CORE_INLINE ALL_C_INLINE
 393 #endif
 394
 395 #if ((H_REVEALS_MODULE_P (SIM_CORE_INLINE) || defined (SIM_INLINE_C)) \
 396      && !defined (SIM_CORE_C) \
 397      && (REVEAL_MODULE_P (SIM_CORE_INLINE)))
 398 # if (SIM_CORE_INLINE & INLINE_GLOBALS)
 399 #  define INLINE_SIM_CORE(TYPE) static INLINE TYPE UNUSED
 400 #  define EXTERN_SIM_CORE_P 0
 401 #else
 402 #  define INLINE_SIM_CORE(TYPE) static TYPE UNUSED
 403 #  define EXTERN_SIM_CORE_P 0
 404 #endif
 405 #else
 406 # define INLINE_SIM_CORE(TYPE) TYPE
 407 # define EXTERN_SIM_CORE_P 1
 408 #endif
 409
 410 #if (SIM_CORE_INLINE & INLINE_LOCALS)
 411 # define STATIC_INLINE_SIM_CORE(TYPE) static INLINE TYPE
 412 #else
 413 # define STATIC_INLINE_SIM_CORE(TYPE) static TYPE
 414 #endif
 415
 416 #define STATIC_SIM_CORE(TYPE) static TYPE
 417
 418
 419
 420 /* sim-endian */
 421
 422 #if !defined (SIM_ENDIAN_INLINE) && (DEFAULT_INLINE)
 423 # define SIM_ENDIAN_INLINE ALL_H_INLINE
 424 #endif
 425
 426 #if ((H_REVEALS_MODULE_P (SIM_ENDIAN_INLINE) || defined (SIM_INLINE_C)) \
 427      && !defined (SIM_ENDIAN_C) \
 428      && (REVEAL_MODULE_P (SIM_ENDIAN_INLINE)))
 429 # if (SIM_ENDIAN_INLINE & INLINE_GLOBALS)
 430 #  define INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE UNUSED
 431 #  define EXTERN_SIM_ENDIAN_P 0
 432 # else
 433 #  define INLINE_SIM_ENDIAN(TYPE) static TYPE UNUSED
 434 #  define EXTERN_SIM_ENDIAN_P 0
 435 # endif
 436 #else
 437 # define INLINE_SIM_ENDIAN(TYPE) TYPE
 438 # define EXTERN_SIM_ENDIAN_P 1
 439 #endif
 440
 441 #if (SIM_ENDIAN_INLINE & INLINE_LOCALS)
 442 # define STATIC_INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE
 443 #else
 444 # define STATIC_INLINE_SIM_ENDIAN(TYPE) static TYPE
 445 #endif
 446
 447 #define STATIC_SIM_ENDIAN(TYPE) static TYPE
 448
 449
 450
 451 /* sim-events */
 452
 453 #if !defined (SIM_EVENTS_INLINE) && (DEFAULT_INLINE)
 454 # define SIM_EVENTS_INLINE ALL_C_INLINE
 455 #endif
 456
 457 #if ((H_REVEALS_MODULE_P (SIM_EVENTS_INLINE) || defined (SIM_INLINE_C)) \
 458      && !defined (SIM_EVENTS_C) \
 459      && (REVEAL_MODULE_P (SIM_EVENTS_INLINE)))
 460 # if (SIM_EVENTS_INLINE & INLINE_GLOBALS)
 461 #  define INLINE_SIM_EVENTS(TYPE) static INLINE TYPE UNUSED
 462 #  define EXTERN_SIM_EVENTS_P 0
 463 # else
 464 #  define INLINE_SIM_EVENTS(TYPE) static TYPE UNUSED
 465 #  define EXTERN_SIM_EVENTS_P 0
 466 # endif
 467 #else
 468 # define INLINE_SIM_EVENTS(TYPE) TYPE
 469 # define EXTERN_SIM_EVENTS_P 1
 470 #endif
 471
 472 #if (SIM_EVENTS_INLINE & INLINE_LOCALS)
 473 # define STATIC_INLINE_SIM_EVENTS(TYPE) static INLINE TYPE
 474 #else
 475 # define STATIC_INLINE_SIM_EVENTS(TYPE) static TYPE
 476 #endif
 477
 478 #define STATIC_SIM_EVENTS(TYPE) static TYPE
 479
 480
 481
 482 /* sim-fpu */
 483
 484 #if !defined (SIM_FPU_INLINE) && (DEFAULT_INLINE)
 485 # define SIM_FPU_INLINE ALL_C_INLINE
 486 #endif
 487
 488 #if ((H_REVEALS_MODULE_P (SIM_FPU_INLINE) || defined (SIM_INLINE_C)) \
 489      && !defined (SIM_FPU_C) \
 490      && (REVEAL_MODULE_P (SIM_FPU_INLINE)))
 491 # if (SIM_FPU_INLINE & INLINE_GLOBALS)
 492 #  define INLINE_SIM_FPU(TYPE) static INLINE TYPE UNUSED
 493 #  define EXTERN_SIM_FPU_P 0
 494 # else
 495 #  define INLINE_SIM_FPU(TYPE) static TYPE UNUSED
 496 #  define EXTERN_SIM_FPU_P 0
 497 # endif
 498 #else
 499 # define INLINE_SIM_FPU(TYPE) TYPE
 500 # define EXTERN_SIM_FPU_P 1
 501 #endif
 502
 503 #if (SIM_FPU_INLINE & INLINE_LOCALS)
 504 # define STATIC_INLINE_SIM_FPU(TYPE) static INLINE TYPE
 505 #else
 506 # define STATIC_INLINE_SIM_FPU(TYPE) static TYPE
 507 #endif
 508
 509 #define STATIC_SIM_FPU(TYPE) static TYPE
 510
 511
 512
 513 /* sim-types */
 514
 515 #if ((H_REVEALS_MODULE_P (SIM_TYPES_INLINE) || defined (SIM_INLINE_C)) \
 516      && !defined (SIM_TYPES_C) \
 517      && (REVEAL_MODULE_P (SIM_TYPES_INLINE)))
 518 # if (SIM_TYPES_INLINE & INLINE_GLOBALS)
 519 #  define INLINE_SIM_TYPES(TYPE) static INLINE TYPE UNUSED
 520 #  define EXTERN_SIM_TYPES_P 0
 521 # else
 522 #  define INLINE_SIM_TYPES(TYPE) static TYPE UNUSED
 523 #  define EXTERN_SIM_TYPES_P 0
 524 # endif
 525 #else
 526 # define INLINE_SIM_TYPES(TYPE) TYPE
 527 # define EXTERN_SIM_TYPES_P 1
 528 #endif
 529
 530 #if (SIM_TYPES_INLINE & INLINE_LOCALS)
 531 # define STATIC_INLINE_SIM_TYPES(TYPE) static INLINE TYPE
 532 #else
 533 # define STATIC_INLINE_SIM_TYPES(TYPE) static TYPE
 534 #endif
 535
 536 #define STATIC_SIM_TYPES(TYPE) static TYPE
 537
 538
 539
 540 /* sim_main */
 541
 542 #if !defined (SIM_MAIN_INLINE) && (DEFAULT_INLINE)
 543 # define SIM_MAIN_INLINE (ALL_C_INLINE)
 544 #endif
 545
 546 #if ((H_REVEALS_MODULE_P (SIM_MAIN_INLINE) || defined (SIM_INLINE_C)) \
 547      && !defined (SIM_MAIN_C) \
 548      && (REVEAL_MODULE_P (SIM_MAIN_INLINE)))
 549 # if (SIM_MAIN_INLINE & INLINE_GLOBALS)
 550 #  define INLINE_SIM_MAIN(TYPE) static INLINE TYPE UNUSED
 551 #  define EXTERN_SIM_MAIN_P 0
 552 # else
 553 #  define INLINE_SIM_MAIN(TYPE) static TYPE UNUSED
 554 #  define EXTERN_SIM_MAIN_P 0
 555 # endif
 556 #else
 557 # define INLINE_SIM_MAIN(TYPE) TYPE
 558 # define EXTERN_SIM_MAIN_P 1
 559 #endif
 560
 561 #if (SIM_MAIN_INLINE & INLINE_LOCALS)
 562 # define STATIC_INLINE_SIM_MAIN(TYPE) static INLINE TYPE
 563 #else
 564 # define STATIC_INLINE_SIM_MAIN(TYPE) static TYPE
 565 #endif
 566
 567 #define STATIC_SIM_MAIN(TYPE) static TYPE
 568 \f
 569 /* engine */
 570
 571 #if ((H_REVEALS_MODULE_P (ENGINE_INLINE) || defined (SIM_INLINE_C)) \
 572      && !defined (ENGINE_C) \
 573      && (REVEAL_MODULE_P (ENGINE_INLINE)))
 574 # if (ENGINE_INLINE & INLINE_GLOBALS)
 575 #  define INLINE_ENGINE(TYPE) static INLINE TYPE UNUSED
 576 #  define EXTERN_ENGINE_P 0
 577 # else
 578 #  define INLINE_ENGINE(TYPE) static TYPE UNUSED
 579 #  define EXTERN_ENGINE_P 0
 580 # endif
 581 #else
 582 # define INLINE_ENGINE(TYPE) TYPE
 583 # define EXTERN_ENGINE_P 1
 584 #endif
 585
 586 #if (ENGINE_INLINE & INLINE_LOCALS)
 587 # define STATIC_INLINE_ENGINE(TYPE) static INLINE TYPE
 588 #else
 589 # define STATIC_INLINE_ENGINE(TYPE) static TYPE
 590 #endif
 591
 592 #define STATIC_ENGINE(TYPE) static TYPE
 593
 594
 595
 596 /* icache */
 597
 598 #if ((H_REVEALS_MODULE_P (ICACHE_INLINE) || defined (SIM_INLINE_C)) \
 599      && !defined (ICACHE_C) \
 600      && (REVEAL_MODULE_P (ICACHE_INLINE)))
 601 # if (ICACHE_INLINE & INLINE_GLOBALS)
 602 #  define INLINE_ICACHE(TYPE) static INLINE TYPE UNUSED
 603 #  define EXTERN_ICACHE_P 0
 604 #else
 605 #  define INLINE_ICACHE(TYPE) static TYPE UNUSED
 606 #  define EXTERN_ICACHE_P 0
 607 #endif
 608 #else
 609 # define INLINE_ICACHE(TYPE) TYPE
 610 # define EXTERN_ICACHE_P 1
 611 #endif
 612
 613 #if (ICACHE_INLINE & INLINE_LOCALS)
 614 # define STATIC_INLINE_ICACHE(TYPE) static INLINE TYPE
 615 #else
 616 # define STATIC_INLINE_ICACHE(TYPE) static TYPE
 617 #endif
 618
 619 #define STATIC_ICACHE(TYPE) static TYPE
 620
 621
 622
 623 /* idecode */
 624
 625 #if ((H_REVEALS_MODULE_P (IDECODE_INLINE) || defined (SIM_INLINE_C)) \
 626      && !defined (IDECODE_C) \
 627      && (REVEAL_MODULE_P (IDECODE_INLINE)))
 628 # if (IDECODE_INLINE & INLINE_GLOBALS)
 629 #  define INLINE_IDECODE(TYPE) static INLINE TYPE UNUSED
 630 #  define EXTERN_IDECODE_P 0
 631 #else
 632 #  define INLINE_IDECODE(TYPE) static TYPE UNUSED
 633 #  define EXTERN_IDECODE_P 0
 634 #endif
 635 #else
 636 # define INLINE_IDECODE(TYPE) TYPE
 637 # define EXTERN_IDECODE_P 1
 638 #endif
 639
 640 #if (IDECODE_INLINE & INLINE_LOCALS)
 641 # define STATIC_INLINE_IDECODE(TYPE) static INLINE TYPE
 642 #else
 643 # define STATIC_INLINE_IDECODE(TYPE) static TYPE
 644 #endif
 645
 646 #define STATIC_IDECODE(TYPE) static TYPE
 647
 648
 649
 650 /* semantics */
 651
 652 #if ((H_REVEALS_MODULE_P (SEMANTICS_INLINE) || defined (SIM_INLINE_C)) \
 653      && !defined (SEMANTICS_C) \
 654      && (REVEAL_MODULE_P (SEMANTICS_INLINE)))
 655 # if (SEMANTICS_INLINE & INLINE_GLOBALS)
 656 #  define INLINE_SEMANTICS(TYPE) static INLINE TYPE UNUSED
 657 #  define EXTERN_SEMANTICS_P 0
 658 #else
 659 #  define INLINE_SEMANTICS(TYPE) static TYPE UNUSED
 660 #  define EXTERN_SEMANTICS_P 0
 661 #endif
 662 #else
 663 # define INLINE_SEMANTICS(TYPE) TYPE
 664 # define EXTERN_SEMANTICS_P 1
 665 #endif
 666
 667 #if EXTERN_SEMANTICS_P
 668 # define EXTERN_SEMANTICS(TYPE) TYPE
 669 #else
 670 # define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED
 671 #endif
 672
 673 #if (SEMANTICS_INLINE & INLINE_LOCALS)
 674 # define STATIC_INLINE_SEMANTICS(TYPE) static INLINE TYPE
 675 #else
 676 # define STATIC_INLINE_SEMANTICS(TYPE) static TYPE
 677 #endif
 678
 679 #define STATIC_SEMANTICS(TYPE) static TYPE
 680
 681
 682
 683 /* support */
 684
 685 #if !defined (SUPPORT_INLINE) && (DEFAULT_INLINE)
 686 # define SUPPORT_INLINE ALL_C_INLINE
 687 #endif
 688
 689 #if ((H_REVEALS_MODULE_P (SUPPORT_INLINE) || defined (SIM_INLINE_C)) \
 690      && !defined (SUPPORT_C) \
 691      && (REVEAL_MODULE_P (SUPPORT_INLINE)))
 692 # if (SUPPORT_INLINE & INLINE_GLOBALS)
 693 #  define INLINE_SUPPORT(TYPE) static INLINE TYPE UNUSED
 694 #  define EXTERN_SUPPORT_P 0
 695 #else
 696 #  define INLINE_SUPPORT(TYPE) static TYPE UNUSED
 697 #  define EXTERN_SUPPORT_P 0
 698 #endif
 699 #else
 700 # define INLINE_SUPPORT(TYPE) TYPE
 701 # define EXTERN_SUPPORT_P 1
 702 #endif
 703
 704 #if (SUPPORT_INLINE & INLINE_LOCALS)
 705 # define STATIC_INLINE_SUPPORT(TYPE) static INLINE TYPE
 706 #else
 707 # define STATIC_INLINE_SUPPORT(TYPE) static TYPE
 708 #endif
 709
 710 #define STATIC_SUPPORT(TYPE) static TYPE
 711
 712
 713
 714 #endif