Commit | Line | Data |
---|---|---|
3971886a AC |
1 | /* This file is part of the program psim. |
2 | ||
3 | Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au> | |
4 | Copyright (C) 1997, Free Software Foundation, Inc. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
18 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
19 | ||
20 | */ | |
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 fine grained control over what is and what | |
31 | isn't made inline. For instance it can control things down to a | |
32 | specific modules static routines. Doing this allows the compiler | |
33 | to both eliminate the overhead of function calls and (as a | |
34 | consequence) also eliminate further dead code. | |
35 | ||
36 | On a CISC (x86) I've found that I can achieve an order of magintude | |
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 Do not inline any thing for the given module | |
44 | ||
45 | The following additional values are `bit fields' and can be | |
46 | combined. | |
47 | ||
48 | REVEAL_MODULE: | |
49 | ||
50 | Include the C file for the module into the file being compiled | |
51 | but do not make the functions within the module inline. | |
52 | ||
53 | While of no apparent benefit, this makes it possible for the | |
54 | included module, when compiled to inline its calls to what | |
55 | would otherwize be external functions. | |
56 | ||
57 | INLINE_MODULE: | |
58 | ||
59 | Make external functions within the module `inline'. Thus if | |
60 | the module is included into a file being compiled, calls to | |
61 | its funtions can be eliminated. 2 implies 1. | |
62 | ||
63 | INLINE_LOCALS: | |
64 | ||
65 | Make internal (static) functions within the module `inline'. | |
66 | ||
67 | In addition to this, modules have been put into two categories. | |
68 | ||
69 | INCLUDED_BY_MODULE | |
70 | ||
71 | eg sim-endian.h sim-bits.h | |
72 | ||
73 | Because these modules are small and simple and do not have | |
74 | any complex interdendencies they are configured, if | |
75 | <module>_INLINE is so enabled, to inline themselves in all | |
76 | modules that include those files. | |
77 | ||
78 | For the default build, this is a real win as all byte | |
79 | conversion and bit manipulation functions are inlined. | |
80 | ||
81 | !INCLUDED_BY_MODULE | |
82 | ||
83 | Complex modules - the rest | |
84 | ||
85 | These are all handled using the files sim-inline.h and | |
86 | sim-inline.c. The main simulator engine includes both of | |
87 | these and hence includes all remaining code. | |
88 | ||
89 | The following abreviations are available: | |
90 | ||
91 | INCLUDE_MODULE == (REVEAL_MODULE | INLINE_MODULE) | |
92 | ||
93 | ALL_INLINE == (REVEAL_MODULE | INLINE_MODULE | INLINE_LOCALS) | |
94 | ||
95 | ALL_BY_MODULE = (INCLUDED_BY_MODULE | ALL_INLINE) | |
96 | ||
97 | IMPLEMENTATION: | |
98 | ||
99 | The inline ability is enabled by prefixing every data / function | |
100 | declaration and definition with one of the following: | |
101 | ||
102 | ||
103 | INLINE_<module> | |
104 | ||
105 | Prefix to any global function that is a candidate for being | |
106 | inline. | |
107 | ||
108 | values - `', `static', `static INLINE' | |
109 | ||
110 | ||
111 | EXTERN_<module> | |
112 | ||
113 | Prefix to any global data structures for the module. Global | |
114 | functions that are not to be inlined shall also be prefixed | |
115 | with this. | |
116 | ||
117 | values - `', `static', `static' | |
118 | ||
119 | ||
120 | STATIC_INLINE_<module> | |
121 | ||
122 | Prefix to any local (static) function that is a candidate for | |
123 | being made inline. | |
124 | ||
125 | values - `static', `static INLINE' | |
126 | ||
127 | ||
128 | static | |
129 | ||
130 | Prefix all local data structures. Local functions that are not | |
131 | to be inlined shall also be prefixed with this. | |
132 | ||
133 | values - `static', `static' | |
134 | ||
135 | nb: will not work for modules that are being inlined for every | |
136 | use (white lie). | |
137 | ||
138 | ||
139 | extern | |
140 | #ifndef _SIM_INLINE_C_ | |
141 | #endif | |
142 | ||
143 | Prefix to any declaration of a global object (function or | |
144 | variable) that should not be inlined and should have only one | |
145 | definition. The #ifndef wrapper goes around the definition | |
146 | propper to ensure that only one copy is generated. | |
147 | ||
148 | nb: this will not work when a module is being inlined for every | |
149 | use. | |
150 | ||
151 | ||
152 | STATIC_<module> | |
153 | ||
154 | Replaced by either `static' or `EXTERN_MODULE'. | |
155 | ||
156 | ||
157 | REALITY CHECK: | |
158 | ||
159 | This is not for the faint hearted. I've seen GCC get up to 500mb | |
160 | trying to compile what this can create. | |
161 | ||
162 | Some of the modules do not yet implement the WITH_INLINE_STATIC | |
163 | option. Instead they use the macro STATIC_INLINE to control their | |
164 | local function. | |
165 | ||
166 | Because of the way that GCC parses __attribute__(), the macro's | |
167 | need to be adjacent to the functioin name rather then at the start | |
168 | of the line vis: | |
169 | ||
170 | int STATIC_INLINE_MODULE f(void); | |
171 | void INLINE_MODULE *g(void); | |
172 | ||
173 | */ | |
174 | ||
175 | ||
176 | #define REVEAL_MODULE 1 | |
177 | #define INLINE_MODULE 2 | |
178 | #define INCLUDE_MODULE (INLINE_MODULE | REVEAL_MODULE) | |
179 | #define INLINE_LOCALS 4 | |
180 | #define ALL_INLINE 7 | |
181 | #define ALL_BY_MODULE (INCLUDED_BY_MODULE | ALL_INLINE) | |
182 | ||
183 | #define INCLUDED_BY_MODULE 16 | |
184 | #define REGPARM_MODULE 32 | |
185 | ||
186 | ||
187 | /* Default macro to simplify control several of key the inlines */ | |
188 | ||
189 | #ifndef DEFAULT_INLINE | |
190 | #define DEFAULT_INLINE INLINE_LOCALS | |
191 | #endif | |
192 | ||
193 | ||
194 | ||
195 | /* Your compilers inline prefix */ | |
196 | ||
197 | #ifndef INLINE | |
198 | #if defined(__GNUC__) && defined(__OPTIMIZE__) | |
199 | #define INLINE __inline__ | |
200 | #else | |
201 | #define INLINE /*inline*/ | |
202 | #endif | |
203 | #endif | |
204 | ||
205 | ||
206 | ||
207 | /* Your compiler's static prefix */ | |
208 | ||
209 | #ifndef STATIC_INLINE | |
210 | #define STATIC_INLINE static INLINE | |
211 | #endif | |
212 | ||
213 | ||
214 | ||
215 | /* Your compiler's no-return reserved word */ | |
216 | ||
217 | #ifndef NORETURN | |
218 | #define NORETURN | |
219 | #endif | |
220 | ||
221 | ||
222 | ||
223 | /* Your compilers's unused reserved word */ | |
224 | ||
225 | #if !defined (UNUSED) | |
226 | #if (!defined(__GNUC__) \ | |
227 | || (__GNUC__ < 2) \ | |
228 | || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)) | |
229 | #define UNUSED | |
230 | #else | |
231 | #define UNUSED __attribute__((__unused__)) | |
232 | #endif | |
233 | #endif | |
234 | ||
235 | ||
236 | ||
237 | ||
238 | /* Your compilers nonstandard function call mechanism prefix */ | |
239 | ||
240 | #if !defined REGPARM | |
241 | #if defined(__GNUC__) && (defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__)) | |
242 | #if (WITH_REGPARM && WITH_STDCALL) | |
243 | #define REGPARM __attribute__((__regparm__(WITH_REGPARM),__stdcall__)) | |
244 | #else | |
245 | #if (WITH_REGPARM && !WITH_STDCALL) | |
246 | #define REGPARM __attribute__((__regparm__(WITH_REGPARM))) | |
247 | #else | |
248 | #if (!WITH_REGPARM && WITH_STDCALL) | |
249 | #define REGPARM __attribute__((__stdcall__)) | |
250 | #endif | |
251 | #endif | |
252 | #endif | |
253 | #endif | |
254 | #endif | |
255 | ||
256 | #if !defined REGPARM | |
257 | #define REGPARM | |
258 | #endif | |
259 | ||
260 | ||
261 | ||
262 | /* sim-bits */ | |
263 | ||
264 | #if (SIM_BITS_INLINE & REGPARM_MODULE) | |
265 | # define REGPARM_SIM_BITS REGPARM | |
266 | #else | |
267 | # define REGPARM_SIM_BITS | |
268 | #endif | |
269 | ||
270 | #if (((SIM_BITS_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
271 | && !defined(_SIM_BITS_C_) && (SIM_BITS_INLINE & INCLUDE_MODULE)) | |
272 | # if (SIM_BITS_INLINE & INLINE_MODULE) | |
273 | # define INLINE_SIM_BITS(TYPE) static INLINE TYPE UNUSED | |
274 | # define EXTERN_SIM_BITS(TYPE) static TYPE UNUSED REGPARM_SIM_BITS | |
275 | # else | |
276 | # define INLINE_SIM_BITS(TYPE) static TYPE UNUSED REGPARM_SIM_BITS | |
277 | # define EXTERN_SIM_BITS(TYPE) static TYPE UNUSED REGPARM_SIM_BITS | |
278 | # endif | |
279 | #else | |
280 | # define INLINE_SIM_BITS(TYPE) TYPE REGPARM_SIM_BITS | |
281 | # define EXTERN_SIM_BITS(TYPE) TYPE REGPARM_SIM_BITS | |
282 | #endif | |
283 | ||
284 | #if (SIM_BITS_INLINE & INLINE_LOCALS) | |
285 | # define STATIC_INLINE_SIM_BITS(TYPE) static INLINE TYPE | |
286 | #else | |
287 | # define STATIC_INLINE_SIM_BITS(TYPE) static TYPE REGPARM_SIM_BITS | |
288 | #endif | |
289 | ||
290 | ||
291 | ||
292 | /* sim-core */ | |
293 | ||
294 | #if (SIM_CORE_INLINE & REGPARM_MODULE) | |
295 | # define REGPARM_SIM_CORE REGPARM | |
296 | #else | |
297 | # define REGPARM_SIM_CORE | |
298 | #endif | |
299 | ||
300 | #if (((SIM_CORE_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
301 | && !defined(_SIM_CORE_C_) && (SIM_CORE_INLINE & INCLUDE_MODULE)) | |
302 | # if (SIM_CORE_INLINE & INLINE_MODULE) | |
303 | # define INLINE_SIM_CORE(TYPE) static INLINE TYPE UNUSED | |
304 | # define EXTERN_SIM_CORE(TYPE) static TYPE UNUSED REGPARM_SIM_CORE | |
305 | #else | |
306 | # define INLINE_SIM_CORE(TYPE) static TYPE UNUSED REGPARM_SIM_CORE | |
307 | # define EXTERN_SIM_CORE(TYPE) static TYPE UNUSED REGPARM_SIM_CORE | |
308 | #endif | |
309 | #else | |
310 | # define INLINE_SIM_CORE(TYPE) TYPE REGPARM_SIM_CORE | |
311 | # define EXTERN_SIM_CORE(TYPE) TYPE REGPARM_SIM_CORE | |
312 | #endif | |
313 | ||
314 | #if (SIM_CORE_INLINE & INLINE_LOCALS) | |
315 | # define STATIC_INLINE_SIM_CORE(TYPE) static INLINE TYPE | |
316 | #else | |
317 | # define STATIC_INLINE_SIM_CORE(TYPE) static TYPE REGPARM_SIM_CORE | |
318 | #endif | |
319 | ||
320 | ||
321 | ||
322 | /* sim-endian */ | |
323 | ||
324 | #if (SIM_ENDIAN_INLINE & REGPARM_MODULE) | |
325 | # define REGPARM_SIM_ENDIAN REGPARM | |
326 | #else | |
327 | # define REGPARM_SIM_ENDIAN | |
328 | #endif | |
329 | ||
330 | #if (((SIM_ENDIAN_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
331 | && !defined(_SIM_ENDIAN_C_) && (SIM_ENDIAN_INLINE & INCLUDE_MODULE)) | |
332 | # if (SIM_ENDIAN_INLINE & INLINE_MODULE) | |
333 | # define INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE UNUSED | |
334 | # define EXTERN_SIM_ENDIAN(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN | |
335 | # else | |
336 | # define INLINE_SIM_ENDIAN(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN | |
337 | # define EXTERN_SIM_ENDIAN(TYPE) static TYPE UNUSED REGPARM_SIM_ENDIAN | |
338 | # endif | |
339 | #else | |
340 | # define INLINE_SIM_ENDIAN(TYPE) TYPE REGPARM_SIM_ENDIAN | |
341 | # define EXTERN_SIM_ENDIAN(TYPE) TYPE REGPARM_SIM_ENDIAN | |
342 | #endif | |
343 | ||
344 | #if (SIM_ENDIAN_INLINE & INLINE_LOCALS) | |
345 | # define STATIC_INLINE_SIM_ENDIAN(TYPE) static INLINE TYPE | |
346 | #else | |
347 | # define STATIC_INLINE_SIM_ENDIAN(TYPE) static TYPE REGPARM_SIM_ENDIAN | |
348 | #endif | |
349 | ||
350 | ||
351 | ||
352 | /* sim-events */ | |
353 | ||
354 | #if (SIM_EVENTS_INLINE & REGPARM_MODULE) | |
355 | # define REGPARM_SIM_EVENTS REGPARM | |
356 | #else | |
357 | # define REGPARM_SIM_EVENTS | |
358 | #endif | |
359 | ||
360 | #if (((SIM_EVENTS_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
361 | && !defined(_SIM_EVENTS_C_) && (SIM_EVENTS_INLINE & INCLUDE_MODULE)) | |
362 | # if (SIM_EVENTS_INLINE & INLINE_MODULE) | |
363 | # define INLINE_SIM_EVENTS(TYPE) static INLINE TYPE UNUSED | |
364 | # define EXTERN_SIM_EVENTS(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS | |
365 | # else | |
366 | # define INLINE_SIM_EVENTS(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS | |
367 | # define EXTERN_SIM_EVENTS(TYPE) static TYPE UNUSED REGPARM_SIM_EVENTS | |
368 | # endif | |
369 | #else | |
370 | # define INLINE_SIM_EVENTS(TYPE) TYPE REGPARM_SIM_EVENTS | |
371 | # define EXTERN_SIM_EVENTS(TYPE) TYPE REGPARM_SIM_EVENTS | |
372 | #endif | |
373 | ||
374 | #if (SIM_EVENTS_INLINE & INLINE_LOCALS) | |
375 | # define STATIC_INLINE_SIM_EVENTS(TYPE) static INLINE TYPE | |
376 | #else | |
377 | # define STATIC_INLINE_SIM_EVENTS(TYPE) static TYPE REGPARM_SIM_EVENTS | |
378 | #endif | |
379 | ||
380 | ||
381 | ||
382 | /* sim-fpu */ | |
383 | ||
384 | #if (SIM_FPU_INLINE & REGPARM_MODULE) | |
385 | # define REGPARM_SIM_FPU REGPARM | |
386 | #else | |
387 | # define REGPARM_SIM_FPU | |
388 | #endif | |
389 | ||
390 | #if (((SIM_FPU_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
391 | && !defined(_SIM_FPU_C_) && (SIM_FPU_INLINE & INCLUDE_MODULE)) | |
392 | # if (SIM_FPU_INLINE & INLINE_MODULE) | |
393 | # define INLINE_SIM_FPU(TYPE) static INLINE TYPE UNUSED | |
394 | # define EXTERN_SIM_FPU(TYPE) static TYPE UNUSED REGPARM_SIM_FPU | |
395 | # else | |
396 | # define INLINE_SIM_FPU(TYPE) static TYPE UNUSED REGPARM_SIM_FPU | |
397 | # define EXTERN_SIM_FPU(TYPE) static TYPE UNUSED REGPARM_SIM_FPU | |
398 | # endif | |
399 | #else | |
400 | # define INLINE_SIM_FPU(TYPE) TYPE REGPARM_SIM_FPU | |
401 | # define EXTERN_SIM_FPU(TYPE) TYPE REGPARM_SIM_FPU | |
402 | #endif | |
403 | ||
404 | #if (SIM_FPU_INLINE & INLINE_LOCALS) | |
405 | # define STATIC_INLINE_SIM_FPU(TYPE) static INLINE TYPE | |
406 | #else | |
407 | # define STATIC_INLINE_SIM_FPU(TYPE) static TYPE REGPARM_SIM_FPU | |
408 | #endif | |
409 | ||
410 | ||
411 | ||
412 | /* sim-types */ | |
413 | ||
414 | #if (SIM_TYPES_INLINE & REGPARM_MODULE) | |
415 | # define REGPARM_SIM_TYPES REGPARM | |
416 | #else | |
417 | # define REGPARM_SIM_TYPES | |
418 | #endif | |
419 | ||
420 | #if (((SIM_TYPES_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
421 | && !defined(_SIM_TYPES_C_) && (SIM_TYPES_INLINE & INCLUDE_MODULE)) | |
422 | # if (SIM_TYPES_INLINE & INLINE_MODULE) | |
423 | # define INLINE_SIM_TYPES(TYPE) static INLINE TYPE UNUSED | |
424 | # define EXTERN_SIM_TYPES(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES | |
425 | # else | |
426 | # define INLINE_SIM_TYPES(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES | |
427 | # define EXTERN_SIM_TYPES(TYPE) static TYPE UNUSED REGPARM_SIM_TYPES | |
428 | # endif | |
429 | #else | |
430 | # define INLINE_SIM_TYPES(TYPE) TYPE REGPARM_SIM_TYPES | |
431 | # define EXTERN_SIM_TYPES(TYPE) TYPE REGPARM_SIM_TYPES | |
432 | #endif | |
433 | ||
434 | #if (SIM_TYPES_INLINE & INLINE_LOCALS) | |
435 | # define STATIC_INLINE_SIM_TYPES(TYPE) static INLINE TYPE | |
436 | #else | |
437 | # define STATIC_INLINE_SIM_TYPES(TYPE) static TYPE REGPARM_SIM_TYPES | |
438 | #endif | |
439 | ||
440 | ||
441 | ||
442 | /* icache */ | |
443 | ||
444 | #if (ICACHE_INLINE & REGPARM_MODULE) | |
445 | # define REGPARM_ICACHE REGPARM | |
446 | #else | |
447 | # define REGPARM_ICACHE | |
448 | #endif | |
449 | ||
450 | #if (((ICACHE_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
451 | && !defined(_ICACHE_C_) && (ICACHE_INLINE & INCLUDE_MODULE)) | |
452 | # if (ICACHE_INLINE & INLINE_MODULE) | |
453 | # define INLINE_ICACHE(TYPE) static INLINE TYPE UNUSED | |
454 | # define EXTERN_ICACHE(TYPE) static TYPE UNUSED REGPARM_ICACHE | |
455 | #else | |
456 | # define INLINE_ICACHE(TYPE) static TYPE UNUSED REGPARM_ICACHE | |
457 | # define EXTERN_ICACHE(TYPE) static TYPE UNUSED REGPARM_ICACHE | |
458 | #endif | |
459 | #else | |
460 | # define INLINE_ICACHE(TYPE) TYPE REGPARM_ICACHE | |
461 | # define EXTERN_ICACHE(TYPE) TYPE REGPARM_ICACHE | |
462 | #endif | |
463 | ||
464 | #if (ICACHE_INLINE & INLINE_LOCALS) | |
465 | # define STATIC_INLINE_ICACHE(TYPE) static INLINE TYPE | |
466 | #else | |
467 | # define STATIC_INLINE_ICACHE(TYPE) static TYPE REGPARM_ICACHE | |
468 | #endif | |
469 | ||
470 | ||
471 | ||
472 | /* idecode */ | |
473 | ||
474 | #if (IDECODE_INLINE & REGPARM_MODULE) | |
475 | # define REGPARM_IDECODE REGPARM | |
476 | #else | |
477 | # define REGPARM_IDECODE | |
478 | #endif | |
479 | ||
480 | #if (((IDECODE_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
481 | && !defined(_IDECODE_C_) && (IDECODE_INLINE & INCLUDE_MODULE)) | |
482 | # if (IDECODE_INLINE & INLINE_MODULE) | |
483 | # define INLINE_IDECODE(TYPE) static INLINE TYPE UNUSED | |
484 | # define EXTERN_IDECODE(TYPE) static TYPE UNUSED REGPARM_IDECODE | |
485 | #else | |
486 | # define INLINE_IDECODE(TYPE) static TYPE UNUSED REGPARM_IDECODE | |
487 | # define EXTERN_IDECODE(TYPE) static TYPE UNUSED REGPARM_IDECODE | |
488 | #endif | |
489 | #else | |
490 | # define INLINE_IDECODE(TYPE) TYPE REGPARM_IDECODE | |
491 | # define EXTERN_IDECODE(TYPE) TYPE REGPARM_IDECODE | |
492 | #endif | |
493 | ||
494 | #if (IDECODE_INLINE & INLINE_LOCALS) | |
495 | # define STATIC_INLINE_IDECODE(TYPE) static INLINE TYPE | |
496 | #else | |
497 | # define STATIC_INLINE_IDECODE(TYPE) static TYPE REGPARM_IDECODE | |
498 | #endif | |
499 | ||
500 | ||
501 | ||
502 | /* semantics */ | |
503 | ||
504 | #if (SEMANTICS_INLINE & REGPARM_MODULE) | |
505 | # define REGPARM_SEMANTICS REGPARM | |
506 | #else | |
507 | # define REGPARM_SEMANTICS | |
508 | #endif | |
509 | ||
510 | #if (((SEMANTICS_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
511 | && !defined(_SEMANTICS_C_) && (SEMANTICS_INLINE & INCLUDE_MODULE)) | |
512 | # if (SEMANTICS_INLINE & INLINE_MODULE) | |
513 | # define INLINE_SEMANTICS(TYPE) static INLINE TYPE UNUSED | |
514 | # define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS | |
515 | #else | |
516 | # define INLINE_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS | |
517 | # define EXTERN_SEMANTICS(TYPE) static TYPE UNUSED REGPARM_SEMANTICS | |
518 | #endif | |
519 | #else | |
520 | # define INLINE_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS | |
521 | # define EXTERN_SEMANTICS(TYPE) TYPE REGPARM_SEMANTICS | |
522 | #endif | |
523 | ||
524 | #if (SEMANTICS_INLINE & INLINE_LOCALS) | |
525 | # define STATIC_INLINE_SEMANTICS(TYPE) static INLINE TYPE | |
526 | #else | |
527 | # define STATIC_INLINE_SEMANTICS(TYPE) static TYPE REGPARM_SEMANTICS | |
528 | #endif | |
529 | ||
530 | ||
531 | ||
532 | /* support */ | |
533 | ||
534 | #if (SUPPORT_INLINE & REGPARM_MODULE) | |
535 | # define REGPARM_SUPPORT REGPARM | |
536 | #else | |
537 | # define REGPARM_SUPPORT | |
538 | #endif | |
539 | ||
540 | #if (((SUPPORT_INLINE & INCLUDED_BY_MODULE) || defined(_SIM_INLINE_C_)) \ | |
541 | && !defined(_SUPPORT_C_) && (SUPPORT_INLINE & INCLUDE_MODULE)) | |
542 | # if (SUPPORT_INLINE & INLINE_MODULE) | |
543 | # define INLINE_SUPPORT(TYPE) static INLINE TYPE UNUSED | |
544 | # define EXTERN_SUPPORT(TYPE) static TYPE UNUSED REGPARM_SUPPORT | |
545 | #else | |
546 | # define INLINE_SUPPORT(TYPE) static TYPE UNUSED REGPARM_SUPPORT | |
547 | # define EXTERN_SUPPORT(TYPE) static TYPE UNUSED REGPARM_SUPPORT | |
548 | #endif | |
549 | #else | |
550 | # define INLINE_SUPPORT(TYPE) TYPE REGPARM_SUPPORT | |
551 | # define EXTERN_SUPPORT(TYPE) TYPE REGPARM_SUPPORT | |
552 | #endif | |
553 | ||
554 | #if (SUPPORT_INLINE & INLINE_LOCALS) | |
555 | # define STATIC_INLINE_SUPPORT(TYPE) static INLINE TYPE | |
556 | #else | |
557 | # define STATIC_INLINE_SUPPORT(TYPE) static TYPE REGPARM_SUPPORT | |
558 | #endif | |
559 | ||
560 | ||
561 | ||
562 | #endif |