1 /* The common simulator framework for GDB, the GNU Debugger. 2 3 Copyright 2002-2020 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 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 351 352 /* sim_arange */ 353 354 #if !defined (SIM_ARANGE_INLINE) && (DEFAULT_INLINE) 355 # define SIM_ARANGE_INLINE (ALL_H_INLINE) 356 #endif 357 358 #if ((H_REVEALS_MODULE_P (SIM_ARANGE_INLINE) || defined (SIM_INLINE_C)) \ 359 && !defined (SIM_ARANGE_C) \ 360 && (REVEAL_MODULE_P (SIM_ARANGE_INLINE))) 361 # if (SIM_ARANGE_INLINE & INLINE_GLOBALS) 362 # define INLINE_SIM_ARANGE(TYPE) static INLINE TYPE UNUSED 363 # define EXTERN_SIM_ARANGE_P 0 364 # else 365 # define INLINE_SIM_ARANGE(TYPE) static TYPE UNUSED 366 # define EXTERN_SIM_ARANGE_P 0 367 # endif 368 #else 369 # define INLINE_SIM_ARANGE(TYPE) TYPE 370 # define EXTERN_SIM_ARANGE_P 1 371 #endif 372 373 #if (SIM_ARANGE_INLINE & INLINE_LOCALS) 374 # define STATIC_INLINE_SIM_ARANGE(TYPE) static INLINE TYPE 375 #else 376 # define STATIC_INLINE_SIM_ARANGE(TYPE) static TYPE 377 #endif 378 379 #define STATIC_SIM_ARANGE(TYPE) static TYPE 380 381 382 383 /* ***** 384 sim-bits and sim-endian are treated differently from the rest 385 of the modules below. Their default value is ALL_H_INLINE. 386 The rest are ALL_C_INLINE. Don't blink, you'll miss it! 387 ***** 388 */ 389 390 /* sim-bits */ 391 392 #if !defined (SIM_BITS_INLINE) && (DEFAULT_INLINE) 393 # define SIM_BITS_INLINE (ALL_H_INLINE) 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 404 # define EXTERN_SIM_BITS_P 0 405 # endif 406 #else 407 # define INLINE_SIM_BITS(TYPE) TYPE 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 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 ((H_REVEALS_MODULE_P (SIM_CORE_INLINE) || defined (SIM_INLINE_C)) \ 428 && !defined (SIM_CORE_C) \ 429 && (REVEAL_MODULE_P (SIM_CORE_INLINE))) 430 # if (SIM_CORE_INLINE & INLINE_GLOBALS) 431 # define INLINE_SIM_CORE(TYPE) static INLINE TYPE UNUSED 432 # define EXTERN_SIM_CORE_P 0 433 #else 434 # define INLINE_SIM_CORE(TYPE) static TYPE UNUSED 435 # define EXTERN_SIM_CORE_P 0 436 #endif 437 #else 438 # define INLINE_SIM_CORE(TYPE) TYPE 439 # define EXTERN_SIM_CORE_P 1 440 #endif 441 442 #if (SIM_CORE_INLINE & INLINE_LOCALS) 443 # define STATIC_INLINE_SIM_CORE(TYPE) static INLINE TYPE 444 #else 445 # define STATIC_INLINE_SIM_CORE(TYPE) static TYPE 446 #endif 447 448 #define STATIC_SIM_CORE(TYPE) static TYPE 449 450 451 452 /* sim-endian */ 453 454 #if !defined (SIM_ENDIAN_INLINE) && (DEFAULT_INLINE) 455 # define SIM_ENDIAN_INLINE ALL_H_INLINE 456 #endif 457 458 #if ((H_REVEALS_MODULE_P (SIM_ENDIAN_INLINE) || defined (SIM_INLINE_C)) \ 459 && !defined (SIM_ENDIAN_C) \ 460 && (REVEAL_MODULE_P (SIM_ENDIAN_INLINE))) 461 # if (SIM_ENDIAN_INLINE & INLINE_GLOBALS) 462 # define INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE UNUSED 463 # define EXTERN_SIM_ENDIAN_P 0 464 # else 465 # define INLINE_SIM_ENDIAN(TYPE) static TYPE UNUSED 466 # define EXTERN_SIM_ENDIAN_P 0 467 # endif 468 #else 469 # define INLINE_SIM_ENDIAN(TYPE) TYPE 470 # define EXTERN_SIM_ENDIAN_P 1 471 #endif 472 473 #if (SIM_ENDIAN_INLINE & INLINE_LOCALS) 474 # define STATIC_INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE 475 #else 476 # define STATIC_INLINE_SIM_ENDIAN(TYPE) static TYPE 477 #endif 478 479 #define STATIC_SIM_ENDIAN(TYPE) static TYPE 480 481 482 483 /* sim-events */ 484 485 #if !defined (SIM_EVENTS_INLINE) && (DEFAULT_INLINE) 486 # define SIM_EVENTS_INLINE ALL_C_INLINE 487 #endif 488 489 #if ((H_REVEALS_MODULE_P (SIM_EVENTS_INLINE) || defined (SIM_INLINE_C)) \ 490 && !defined (SIM_EVENTS_C) \ 491 && (REVEAL_MODULE_P (SIM_EVENTS_INLINE))) 492 # if (SIM_EVENTS_INLINE & INLINE_GLOBALS) 493 # define INLINE_SIM_EVENTS(TYPE) static INLINE TYPE UNUSED 494 # define EXTERN_SIM_EVENTS_P 0 495 # else 496 # define INLINE_SIM_EVENTS(TYPE) static TYPE UNUSED 497 # define EXTERN_SIM_EVENTS_P 0 498 # endif 499 #else 500 # define INLINE_SIM_EVENTS(TYPE) TYPE 501 # define EXTERN_SIM_EVENTS_P 1 502 #endif 503 504 #if (SIM_EVENTS_INLINE & INLINE_LOCALS) 505 # define STATIC_INLINE_SIM_EVENTS(TYPE) static INLINE TYPE 506 #else 507 # define STATIC_INLINE_SIM_EVENTS(TYPE) static TYPE 508 #endif 509 510 #define STATIC_SIM_EVENTS(TYPE) static TYPE 511 512 513 514 /* sim-fpu */ 515 516 #if !defined (SIM_FPU_INLINE) && (DEFAULT_INLINE) 517 # define SIM_FPU_INLINE ALL_C_INLINE 518 #endif 519 520 #if ((H_REVEALS_MODULE_P (SIM_FPU_INLINE) || defined (SIM_INLINE_C)) \ 521 && !defined (SIM_FPU_C) \ 522 && (REVEAL_MODULE_P (SIM_FPU_INLINE))) 523 # if (SIM_FPU_INLINE & INLINE_GLOBALS) 524 # define INLINE_SIM_FPU(TYPE) static INLINE TYPE UNUSED 525 # define EXTERN_SIM_FPU_P 0 526 # else 527 # define INLINE_SIM_FPU(TYPE) static TYPE UNUSED 528 # define EXTERN_SIM_FPU_P 0 529 # endif 530 #else 531 # define INLINE_SIM_FPU(TYPE) TYPE 532 # define EXTERN_SIM_FPU_P 1 533 #endif 534 535 #if (SIM_FPU_INLINE & INLINE_LOCALS) 536 # define STATIC_INLINE_SIM_FPU(TYPE) static INLINE TYPE 537 #else 538 # define STATIC_INLINE_SIM_FPU(TYPE) static TYPE 539 #endif 540 541 #define STATIC_SIM_FPU(TYPE) static TYPE 542 543 544 545 /* sim-types */ 546 547 #if ((H_REVEALS_MODULE_P (SIM_TYPES_INLINE) || defined (SIM_INLINE_C)) \ 548 && !defined (SIM_TYPES_C) \ 549 && (REVEAL_MODULE_P (SIM_TYPES_INLINE))) 550 # if (SIM_TYPES_INLINE & INLINE_GLOBALS) 551 # define INLINE_SIM_TYPES(TYPE) static INLINE TYPE UNUSED 552 # define EXTERN_SIM_TYPES_P 0 553 # else 554 # define INLINE_SIM_TYPES(TYPE) static TYPE UNUSED 555 # define EXTERN_SIM_TYPES_P 0 556 # endif 557 #else 558 # define INLINE_SIM_TYPES(TYPE) TYPE 559 # define EXTERN_SIM_TYPES_P 1 560 #endif 561 562 #if (SIM_TYPES_INLINE & INLINE_LOCALS) 563 # define STATIC_INLINE_SIM_TYPES(TYPE) static INLINE TYPE 564 #else 565 # define STATIC_INLINE_SIM_TYPES(TYPE) static TYPE 566 #endif 567 568 #define STATIC_SIM_TYPES(TYPE) static TYPE 569 570 571 572 /* sim_main */ 573 574 #if !defined (SIM_MAIN_INLINE) && (DEFAULT_INLINE) 575 # define SIM_MAIN_INLINE (ALL_C_INLINE) 576 #endif 577 578 #if ((H_REVEALS_MODULE_P (SIM_MAIN_INLINE) || defined (SIM_INLINE_C)) \ 579 && !defined (SIM_MAIN_C) \ 580 && (REVEAL_MODULE_P (SIM_MAIN_INLINE))) 581 # if (SIM_MAIN_INLINE & INLINE_GLOBALS) 582 # define INLINE_SIM_MAIN(TYPE) static INLINE TYPE UNUSED 583 # define EXTERN_SIM_MAIN_P 0 584 # else 585 # define INLINE_SIM_MAIN(TYPE) static TYPE UNUSED 586 # define EXTERN_SIM_MAIN_P 0 587 # endif 588 #else 589 # define INLINE_SIM_MAIN(TYPE) TYPE 590 # define EXTERN_SIM_MAIN_P 1 591 #endif 592 593 #if (SIM_MAIN_INLINE & INLINE_LOCALS) 594 # define STATIC_INLINE_SIM_MAIN(TYPE) static INLINE TYPE 595 #else 596 # define STATIC_INLINE_SIM_MAIN(TYPE) static TYPE 597 #endif 598 599 #define STATIC_SIM_MAIN(TYPE) static TYPE 600 601 /* engine */ 602 603 #if ((H_REVEALS_MODULE_P (ENGINE_INLINE) || defined (SIM_INLINE_C)) \ 604 && !defined (ENGINE_C) \ 605 && (REVEAL_MODULE_P (ENGINE_INLINE))) 606 # if (ENGINE_INLINE & INLINE_GLOBALS) 607 # define INLINE_ENGINE(TYPE) static INLINE TYPE UNUSED 608 # define EXTERN_ENGINE_P 0 609 # else 610 # define INLINE_ENGINE(TYPE) static TYPE UNUSED 611 # define EXTERN_ENGINE_P 0 612 # endif 613 #else 614 # define INLINE_ENGINE(TYPE) TYPE 615 # define EXTERN_ENGINE_P 1 616 #endif 617 618 #if (ENGINE_INLINE & INLINE_LOCALS) 619 # define STATIC_INLINE_ENGINE(TYPE) static INLINE TYPE 620 #else 621 # define STATIC_INLINE_ENGINE(TYPE) static TYPE 622 #endif 623 624 #define STATIC_ENGINE(TYPE) static TYPE 625 626 627 628 /* icache */ 629 630 #if ((H_REVEALS_MODULE_P (ICACHE_INLINE) || defined (SIM_INLINE_C)) \ 631 && !defined (ICACHE_C) \ 632 && (REVEAL_MODULE_P (ICACHE_INLINE))) 633 # if (ICACHE_INLINE & INLINE_GLOBALS) 634 # define INLINE_ICACHE(TYPE) static INLINE TYPE UNUSED 635 # define EXTERN_ICACHE_P 0 636 #else 637 # define INLINE_ICACHE(TYPE) static TYPE UNUSED 638 # define EXTERN_ICACHE_P 0 639 #endif 640 #else 641 # define INLINE_ICACHE(TYPE) TYPE 642 # define EXTERN_ICACHE_P 1 643 #endif 644 645 #if (ICACHE_INLINE & INLINE_LOCALS) 646 # define STATIC_INLINE_ICACHE(TYPE) static INLINE TYPE 647 #else 648 # define STATIC_INLINE_ICACHE(TYPE) static TYPE 649 #endif 650 651 #define STATIC_ICACHE(TYPE) static TYPE 652 653 654 655 /* idecode */ 656 657 #if ((H_REVEALS_MODULE_P (IDECODE_INLINE) || defined (SIM_INLINE_C)) \ 658 && !defined (IDECODE_C) \ 659 && (REVEAL_MODULE_P (IDECODE_INLINE))) 660 # if (IDECODE_INLINE & INLINE_GLOBALS) 661 # define INLINE_IDECODE(TYPE) static INLINE TYPE UNUSED 662 # define EXTERN_IDECODE_P 0 663 #else 664 # define INLINE_IDECODE(TYPE) static TYPE UNUSED 665 # define EXTERN_IDECODE_P 0 666 #endif 667 #else 668 # define INLINE_IDECODE(TYPE) TYPE 669 # define EXTERN_IDECODE_P 1 670 #endif 671 672 #if (IDECODE_INLINE & INLINE_LOCALS) 673 # define STATIC_INLINE_IDECODE(TYPE) static INLINE TYPE 674 #else 675 # define STATIC_INLINE_IDECODE(TYPE) static TYPE 676 #endif 677 678 #define STATIC_IDECODE(TYPE) static TYPE 679 680 681 682 /* semantics */ 683 684 #if ((H_REVEALS_MODULE_P (SEMANTICS_INLINE) || defined (SIM_INLINE_C)) \ 685 && !defined (SEMANTICS_C) \ 686 && (REVEAL_MODULE_P (SEMANTICS_INLINE))) 687 # if (SEMANTICS_INLINE & INLINE_GLOBALS) 688 # define INLINE_SEMANTICS(TYPE) static INLINE TYPE UNUSED 689 # define EXTERN_SEMANTICS_P 0 690 #else 691 # define INLINE_SEMANTICS(TYPE) static TYPE UNUSED 692 # define EXTERN_SEMANTICS_P 0 693 #endif 694 #else 695 # define INLINE_SEMANTICS(TYPE) TYPE 696 # define EXTERN_SEMANTICS_P 1 697 #endif 698 699 #if EXTERN_SEMANTICS_P 700 # define EXTERN_SEMANTICS(TYPE) TYPE 701 #else 702 # define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED 703 #endif 704 705 #if (SEMANTICS_INLINE & INLINE_LOCALS) 706 # define STATIC_INLINE_SEMANTICS(TYPE) static INLINE TYPE 707 #else 708 # define STATIC_INLINE_SEMANTICS(TYPE) static TYPE 709 #endif 710 711 #define STATIC_SEMANTICS(TYPE) static TYPE 712 713 714 715 /* support */ 716 717 #if !defined (SUPPORT_INLINE) && (DEFAULT_INLINE) 718 # define SUPPORT_INLINE ALL_C_INLINE 719 #endif 720 721 #if ((H_REVEALS_MODULE_P (SUPPORT_INLINE) || defined (SIM_INLINE_C)) \ 722 && !defined (SUPPORT_C) \ 723 && (REVEAL_MODULE_P (SUPPORT_INLINE))) 724 # if (SUPPORT_INLINE & INLINE_GLOBALS) 725 # define INLINE_SUPPORT(TYPE) static INLINE TYPE UNUSED 726 # define EXTERN_SUPPORT_P 0 727 #else 728 # define INLINE_SUPPORT(TYPE) static TYPE UNUSED 729 # define EXTERN_SUPPORT_P 0 730 #endif 731 #else 732 # define INLINE_SUPPORT(TYPE) TYPE 733 # define EXTERN_SUPPORT_P 1 734 #endif 735 736 #if (SUPPORT_INLINE & INLINE_LOCALS) 737 # define STATIC_INLINE_SUPPORT(TYPE) static INLINE TYPE 738 #else 739 # define STATIC_INLINE_SUPPORT(TYPE) static TYPE 740 #endif 741 742 #define STATIC_SUPPORT(TYPE) static TYPE 743 744 745 746 #endif 747