Commit | Line | Data |
---|---|---|
c906108c SS |
1 | /* This file is part of the program psim. |
2 | ||
3 | Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au> | |
4 | ||
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 2 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 | ||
19 | */ | |
20 | ||
21 | #ifndef _OPTIONS_C_ | |
22 | #define _OPTIONS_C_ | |
23 | ||
24 | #include "cpu.h" | |
25 | #include "options.h" | |
26 | ||
27 | STATIC_INLINE_OPTIONS\ | |
28 | (const char *) | |
29 | options_byte_order (int order) | |
30 | { | |
31 | switch (order) { | |
32 | case 0: return "0"; | |
33 | case BIG_ENDIAN: return "BIG_ENDIAN"; | |
34 | case LITTLE_ENDIAN: return "LITTLE_ENDIAN"; | |
35 | } | |
36 | ||
37 | return "UNKNOWN"; | |
38 | } | |
39 | ||
40 | STATIC_INLINE_OPTIONS\ | |
41 | (const char *) | |
42 | options_env (int env) | |
43 | { | |
44 | switch (env) { | |
45 | case OPERATING_ENVIRONMENT: return "OPERATING"; | |
46 | case VIRTUAL_ENVIRONMENT: return "VIRTUAL"; | |
47 | case USER_ENVIRONMENT: return "USER"; | |
48 | case 0: return "0"; | |
49 | } | |
50 | ||
51 | return "UNKNOWN"; | |
52 | } | |
53 | ||
54 | STATIC_INLINE_OPTIONS\ | |
55 | (const char *) | |
56 | options_align (int align) | |
57 | { | |
58 | switch (align) { | |
59 | case NONSTRICT_ALIGNMENT: return "NONSTRICT"; | |
60 | case STRICT_ALIGNMENT: return "STRICT"; | |
61 | case 0: return "0"; | |
62 | } | |
63 | ||
64 | return "UNKNOWN"; | |
65 | } | |
66 | ||
67 | STATIC_INLINE_OPTIONS\ | |
68 | (const char *) | |
69 | options_float (int float_type) | |
70 | { | |
71 | switch (float_type) { | |
72 | case SOFT_FLOATING_POINT: return "SOFTWARE"; | |
73 | case HARD_FLOATING_POINT: return "HARDWARE"; | |
74 | } | |
75 | ||
76 | return "UNKNOWN"; | |
77 | } | |
78 | ||
79 | STATIC_INLINE_OPTIONS\ | |
80 | (const char *) | |
81 | options_mon (int mon) | |
82 | { | |
83 | switch (mon) { | |
84 | case MONITOR_INSTRUCTION_ISSUE|MONITOR_LOAD_STORE_UNIT: return "ALL"; | |
85 | case MONITOR_INSTRUCTION_ISSUE: return "INSTRUCTION"; | |
86 | case MONITOR_LOAD_STORE_UNIT: return "MEMORY"; | |
87 | case 0: return "0"; | |
88 | } | |
89 | ||
90 | return "UNKNOWN"; | |
91 | } | |
92 | ||
93 | STATIC_INLINE_OPTIONS\ | |
94 | (const char *) | |
95 | options_inline (int in) | |
96 | { | |
97 | switch (in) { | |
98 | case /*0*/ 0: return "0"; | |
99 | case /*1*/ REVEAL_MODULE: return "REVEAL_MODULE"; | |
100 | case /*2*/ INLINE_MODULE: return "INLINE_MODULE"; | |
101 | case /*3*/ REVEAL_MODULE|INLINE_MODULE: return "REVEAL_MODULE|INLINE_MODULE"; | |
d29d5195 MG |
102 | case /*4*/ PSIM_INLINE_LOCALS: return "PSIM_LOCALS_INLINE"; |
103 | case /*5*/ PSIM_INLINE_LOCALS|REVEAL_MODULE: return "PSIM_INLINE_LOCALS|REVEAL_MODULE"; | |
104 | case /*6*/ PSIM_INLINE_LOCALS|INLINE_MODULE: return "PSIM_INLINE_LOCALS|INLINE_MODULE"; | |
c906108c SS |
105 | case /*7*/ ALL_INLINE: return "ALL_INLINE"; |
106 | } | |
107 | return "0"; | |
108 | } | |
109 | ||
110 | ||
111 | INLINE_OPTIONS\ | |
112 | (void) | |
113 | print_options (void) | |
114 | { | |
115 | #if defined(_GNUC_) && defined(__VERSION__) | |
116 | printf_filtered ("Compiled by GCC %s on %s %s\n", __VERSION__, __DATE__, __TIME__); | |
117 | #else | |
118 | printf_filtered ("Compiled on %s %s\n", __DATE__, __TIME__); | |
119 | #endif | |
120 | ||
121 | printf_filtered ("WITH_HOST_BYTE_ORDER = %s\n", options_byte_order (WITH_HOST_BYTE_ORDER)); | |
122 | printf_filtered ("WITH_TARGET_BYTE_ORDER = %s\n", options_byte_order (WITH_TARGET_BYTE_ORDER)); | |
123 | printf_filtered ("WITH_XOR_ENDIAN = %d\n", WITH_XOR_ENDIAN); | |
124 | printf_filtered ("WITH_BSWAP = %d\n", WITH_BSWAP); | |
125 | printf_filtered ("WITH_SMP = %d\n", WITH_SMP); | |
126 | printf_filtered ("WITH_HOST_WORD_BITSIZE = %d\n", WITH_HOST_WORD_BITSIZE); | |
127 | printf_filtered ("WITH_TARGET_WORD_BITSIZE = %d\n", WITH_TARGET_WORD_BITSIZE); | |
128 | printf_filtered ("WITH_ENVIRONMENT = %s\n", options_env(WITH_ENVIRONMENT)); | |
129 | printf_filtered ("WITH_EVENTS = %d\n", WITH_EVENTS); | |
130 | printf_filtered ("WITH_TIME_BASE = %d\n", WITH_TIME_BASE); | |
131 | printf_filtered ("WITH_CALLBACK_MEMORY = %d\n", WITH_CALLBACK_MEMORY); | |
132 | printf_filtered ("WITH_ALIGNMENT = %s\n", options_align (WITH_ALIGNMENT)); | |
133 | printf_filtered ("WITH_FLOATING_POINT = %s\n", options_float (WITH_FLOATING_POINT)); | |
134 | printf_filtered ("WITH_TRACE = %d\n", WITH_TRACE); | |
135 | printf_filtered ("WITH_ASSERT = %d\n", WITH_ASSERT); | |
136 | printf_filtered ("WITH_MON = %s\n", options_mon (WITH_MON)); | |
137 | printf_filtered ("WITH_DEFAULT_MODEL = %s\n", model_name[WITH_DEFAULT_MODEL]); | |
138 | printf_filtered ("WITH_MODEL = %s\n", model_name[WITH_MODEL]); | |
139 | printf_filtered ("WITH_MODEL_ISSUE = %d\n", WITH_MODEL_ISSUE); | |
140 | printf_filtered ("WITH_RESERVED_BITS = %d\n", WITH_RESERVED_BITS); | |
141 | printf_filtered ("WITH_STDIO = %d\n", WITH_STDIO); | |
142 | printf_filtered ("WITH_REGPARM = %d\n", WITH_REGPARM); | |
143 | printf_filtered ("WITH_STDCALL = %d\n", WITH_STDCALL); | |
144 | printf_filtered ("DEFAULT_INLINE = %s\n", options_inline (DEFAULT_INLINE)); | |
145 | printf_filtered ("SIM_ENDIAN_INLINE = %s\n", options_inline (SIM_ENDIAN_INLINE)); | |
146 | printf_filtered ("BITS_INLINE = %s\n", options_inline (BITS_INLINE)); | |
147 | printf_filtered ("CPU_INLINE = %s\n", options_inline (CPU_INLINE)); | |
148 | printf_filtered ("VM_INLINE = %s\n", options_inline (VM_INLINE)); | |
149 | printf_filtered ("CORE_INLINE = %s\n", options_inline (CORE_INLINE)); | |
150 | printf_filtered ("EVENTS_INLINE = %s\n", options_inline (EVENTS_INLINE)); | |
151 | printf_filtered ("MON_INLINE = %s\n", options_inline (MON_INLINE)); | |
152 | printf_filtered ("INTERRUPTS_INLINE = %s\n", options_inline (INTERRUPTS_INLINE)); | |
153 | printf_filtered ("REGISTERS_INLINE = %s\n", options_inline (REGISTERS_INLINE)); | |
154 | printf_filtered ("DEVICE_INLINE = %s\n", options_inline (DEVICE_INLINE)); | |
155 | printf_filtered ("SPREG_INLINE = %s\n", options_inline (SPREG_INLINE)); | |
156 | printf_filtered ("SEMANTICS_INLINE = %s\n", options_inline (SEMANTICS_INLINE)); | |
157 | printf_filtered ("IDECODE_INLINE = %s\n", options_inline (IDECODE_INLINE)); | |
158 | printf_filtered ("OPTIONS_INLINE = %s\n", options_inline (OPTIONS_INLINE)); | |
159 | printf_filtered ("OS_EMUL_INLINE = %s\n", options_inline (OS_EMUL_INLINE)); | |
160 | printf_filtered ("SUPPORT_INLINE = %s\n", options_inline (SUPPORT_INLINE)); | |
161 | ||
162 | #ifdef OPCODE_RULES | |
163 | printf_filtered ("OPCODE rules = %s\n", OPCODE_RULES); | |
164 | #endif | |
165 | ||
166 | #ifdef IGEN_FLAGS | |
167 | printf_filtered ("IGEN_FLAGS = %s\n", IGEN_FLAGS); | |
168 | #endif | |
169 | ||
170 | #ifdef DGEN_FLAGS | |
171 | printf_filtered ("DGEN_FLAGS = %s\n", DGEN_FLAGS); | |
172 | #endif | |
173 | ||
174 | { | |
175 | static const char *const defines[] = { | |
176 | #ifdef __GNUC__ | |
177 | "__GNUC__", | |
178 | #endif | |
179 | ||
180 | #ifdef __STRICT_ANSI__ | |
181 | "__STRICT_ANSI__", | |
182 | #endif | |
183 | ||
184 | #ifdef __CHAR_UNSIGNED__ | |
185 | "__CHAR_UNSIGNED__", | |
186 | #endif | |
187 | ||
188 | #ifdef __OPTIMIZE__ | |
189 | "__OPTIMIZE__", | |
190 | #endif | |
191 | ||
192 | #ifdef STDC_HEADERS | |
193 | "STDC_HEADERS", | |
194 | #endif | |
195 | ||
196 | #include "defines.h" | |
197 | ||
198 | #ifdef HAVE_TERMIOS_CLINE | |
199 | "HAVE_TERMIOS_CLINE", | |
200 | #endif | |
201 | ||
202 | #ifdef HAVE_TERMIOS_STRUCTURE | |
203 | "HAVE_TERMIOS_STRUCTURE", | |
204 | #endif | |
205 | ||
206 | #ifdef HAVE_TERMIO_CLINE | |
207 | "HAVE_TERMIO_CLINE", | |
208 | #endif | |
209 | ||
210 | #ifdef HAVE_TERMIO_STRUCTURE | |
211 | "HAVE_TERMIO_STRUCTURE", | |
212 | #endif | |
213 | ||
214 | #ifdef HAVE_DEVZERO | |
215 | "HAVE_DEVZERO", | |
216 | #endif | |
217 | }; | |
218 | ||
219 | int i; | |
220 | int max_len = 0; | |
221 | int cols; | |
222 | ||
223 | for (i = 0; i < sizeof (defines) / sizeof (defines[0]); i++) { | |
224 | int len = strlen (defines[i]); | |
225 | if (len > max_len) | |
226 | max_len = len; | |
227 | } | |
228 | ||
229 | cols = 78 / (max_len + 2); | |
230 | if (cols < 0) | |
231 | cols = 1; | |
232 | ||
233 | printf_filtered ("\n#defines:"); | |
234 | for (i = 0; i < sizeof (defines) / sizeof (defines[0]); i++) { | |
235 | const char *const prefix = ((i % cols) == 0) ? "\n" : ""; | |
236 | printf_filtered ("%s %s%*s", prefix, defines[i], | |
237 | (((i == (sizeof (defines) / sizeof (defines[0])) - 1) | |
238 | || (((i + 1) % cols) == 0)) | |
239 | ? 0 | |
240 | : max_len + 4 - strlen (defines[i])), | |
241 | ""); | |
242 | } | |
243 | printf_filtered ("\n"); | |
244 | } | |
245 | } | |
246 | ||
247 | #endif /* _OPTIONS_C_ */ |