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 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-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 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 715