| 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 3 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, see <http://www.gnu.org/licenses/>. |
| 17 | |
| 18 | */ |
| 19 | |
| 20 | #ifndef _OPTIONS_C_ |
| 21 | #define _OPTIONS_C_ |
| 22 | |
| 23 | #include "cpu.h" |
| 24 | #include "options.h" |
| 25 | |
| 26 | STATIC_INLINE_OPTIONS\ |
| 27 | (const char *) |
| 28 | options_byte_order (int order) |
| 29 | { |
| 30 | switch (order) { |
| 31 | case 0: return "0"; |
| 32 | case BIG_ENDIAN: return "BIG_ENDIAN"; |
| 33 | case LITTLE_ENDIAN: return "LITTLE_ENDIAN"; |
| 34 | } |
| 35 | |
| 36 | return "UNKNOWN"; |
| 37 | } |
| 38 | |
| 39 | STATIC_INLINE_OPTIONS\ |
| 40 | (const char *) |
| 41 | options_env (int env) |
| 42 | { |
| 43 | switch (env) { |
| 44 | case OPERATING_ENVIRONMENT: return "OPERATING"; |
| 45 | case VIRTUAL_ENVIRONMENT: return "VIRTUAL"; |
| 46 | case USER_ENVIRONMENT: return "USER"; |
| 47 | case 0: return "0"; |
| 48 | } |
| 49 | |
| 50 | return "UNKNOWN"; |
| 51 | } |
| 52 | |
| 53 | STATIC_INLINE_OPTIONS\ |
| 54 | (const char *) |
| 55 | options_align (int align) |
| 56 | { |
| 57 | switch (align) { |
| 58 | case NONSTRICT_ALIGNMENT: return "NONSTRICT"; |
| 59 | case STRICT_ALIGNMENT: return "STRICT"; |
| 60 | case 0: return "0"; |
| 61 | } |
| 62 | |
| 63 | return "UNKNOWN"; |
| 64 | } |
| 65 | |
| 66 | STATIC_INLINE_OPTIONS\ |
| 67 | (const char *) |
| 68 | options_float (int float_type) |
| 69 | { |
| 70 | switch (float_type) { |
| 71 | case SOFT_FLOATING_POINT: return "SOFTWARE"; |
| 72 | case HARD_FLOATING_POINT: return "HARDWARE"; |
| 73 | } |
| 74 | |
| 75 | return "UNKNOWN"; |
| 76 | } |
| 77 | |
| 78 | STATIC_INLINE_OPTIONS\ |
| 79 | (const char *) |
| 80 | options_mon (int mon) |
| 81 | { |
| 82 | switch (mon) { |
| 83 | case MONITOR_INSTRUCTION_ISSUE|MONITOR_LOAD_STORE_UNIT: return "ALL"; |
| 84 | case MONITOR_INSTRUCTION_ISSUE: return "INSTRUCTION"; |
| 85 | case MONITOR_LOAD_STORE_UNIT: return "MEMORY"; |
| 86 | case 0: return "0"; |
| 87 | } |
| 88 | |
| 89 | return "UNKNOWN"; |
| 90 | } |
| 91 | |
| 92 | STATIC_INLINE_OPTIONS\ |
| 93 | (const char *) |
| 94 | options_inline (int in) |
| 95 | { |
| 96 | switch (in) { |
| 97 | case /*0*/ 0: return "0"; |
| 98 | case /*1*/ REVEAL_MODULE: return "REVEAL_MODULE"; |
| 99 | case /*2*/ INLINE_MODULE: return "INLINE_MODULE"; |
| 100 | case /*3*/ REVEAL_MODULE|INLINE_MODULE: return "REVEAL_MODULE|INLINE_MODULE"; |
| 101 | case /*4*/ PSIM_INLINE_LOCALS: return "PSIM_LOCALS_INLINE"; |
| 102 | case /*5*/ PSIM_INLINE_LOCALS|REVEAL_MODULE: return "PSIM_INLINE_LOCALS|REVEAL_MODULE"; |
| 103 | case /*6*/ PSIM_INLINE_LOCALS|INLINE_MODULE: return "PSIM_INLINE_LOCALS|INLINE_MODULE"; |
| 104 | case /*7*/ ALL_INLINE: return "ALL_INLINE"; |
| 105 | } |
| 106 | return "0"; |
| 107 | } |
| 108 | |
| 109 | |
| 110 | INLINE_OPTIONS\ |
| 111 | (void) |
| 112 | print_options (void) |
| 113 | { |
| 114 | #if defined(_GNUC_) && defined(__VERSION__) |
| 115 | printf_filtered ("Compiled by GCC %s on %s %s\n", __VERSION__, __DATE__, __TIME__); |
| 116 | #else |
| 117 | printf_filtered ("Compiled on %s %s\n", __DATE__, __TIME__); |
| 118 | #endif |
| 119 | |
| 120 | printf_filtered ("WITH_HOST_BYTE_ORDER = %s\n", options_byte_order (WITH_HOST_BYTE_ORDER)); |
| 121 | printf_filtered ("WITH_TARGET_BYTE_ORDER = %s\n", options_byte_order (WITH_TARGET_BYTE_ORDER)); |
| 122 | printf_filtered ("WITH_XOR_ENDIAN = %d\n", WITH_XOR_ENDIAN); |
| 123 | printf_filtered ("WITH_SMP = %d\n", WITH_SMP); |
| 124 | printf_filtered ("WITH_HOST_WORD_BITSIZE = %d\n", WITH_HOST_WORD_BITSIZE); |
| 125 | printf_filtered ("WITH_TARGET_WORD_BITSIZE = %d\n", WITH_TARGET_WORD_BITSIZE); |
| 126 | printf_filtered ("WITH_ENVIRONMENT = %s\n", options_env(WITH_ENVIRONMENT)); |
| 127 | printf_filtered ("WITH_EVENTS = %d\n", WITH_EVENTS); |
| 128 | printf_filtered ("WITH_TIME_BASE = %d\n", WITH_TIME_BASE); |
| 129 | printf_filtered ("WITH_CALLBACK_MEMORY = %d\n", WITH_CALLBACK_MEMORY); |
| 130 | printf_filtered ("WITH_ALIGNMENT = %s\n", options_align (WITH_ALIGNMENT)); |
| 131 | printf_filtered ("WITH_FLOATING_POINT = %s\n", options_float (WITH_FLOATING_POINT)); |
| 132 | printf_filtered ("WITH_TRACE = %d\n", WITH_TRACE); |
| 133 | printf_filtered ("WITH_ASSERT = %d\n", WITH_ASSERT); |
| 134 | printf_filtered ("WITH_MON = %s\n", options_mon (WITH_MON)); |
| 135 | printf_filtered ("WITH_DEFAULT_MODEL = %s\n", model_name[WITH_DEFAULT_MODEL]); |
| 136 | printf_filtered ("WITH_MODEL = %s\n", model_name[WITH_MODEL]); |
| 137 | printf_filtered ("WITH_MODEL_ISSUE = %d\n", WITH_MODEL_ISSUE); |
| 138 | printf_filtered ("WITH_RESERVED_BITS = %d\n", WITH_RESERVED_BITS); |
| 139 | printf_filtered ("WITH_STDIO = %d\n", WITH_STDIO); |
| 140 | printf_filtered ("DEFAULT_INLINE = %s\n", options_inline (DEFAULT_INLINE)); |
| 141 | printf_filtered ("SIM_ENDIAN_INLINE = %s\n", options_inline (SIM_ENDIAN_INLINE)); |
| 142 | printf_filtered ("BITS_INLINE = %s\n", options_inline (BITS_INLINE)); |
| 143 | printf_filtered ("CPU_INLINE = %s\n", options_inline (CPU_INLINE)); |
| 144 | printf_filtered ("VM_INLINE = %s\n", options_inline (VM_INLINE)); |
| 145 | printf_filtered ("CORE_INLINE = %s\n", options_inline (CORE_INLINE)); |
| 146 | printf_filtered ("EVENTS_INLINE = %s\n", options_inline (EVENTS_INLINE)); |
| 147 | printf_filtered ("MON_INLINE = %s\n", options_inline (MON_INLINE)); |
| 148 | printf_filtered ("INTERRUPTS_INLINE = %s\n", options_inline (INTERRUPTS_INLINE)); |
| 149 | printf_filtered ("REGISTERS_INLINE = %s\n", options_inline (REGISTERS_INLINE)); |
| 150 | printf_filtered ("DEVICE_INLINE = %s\n", options_inline (DEVICE_INLINE)); |
| 151 | printf_filtered ("SPREG_INLINE = %s\n", options_inline (SPREG_INLINE)); |
| 152 | printf_filtered ("SEMANTICS_INLINE = %s\n", options_inline (SEMANTICS_INLINE)); |
| 153 | printf_filtered ("IDECODE_INLINE = %s\n", options_inline (IDECODE_INLINE)); |
| 154 | printf_filtered ("OPTIONS_INLINE = %s\n", options_inline (OPTIONS_INLINE)); |
| 155 | printf_filtered ("OS_EMUL_INLINE = %s\n", options_inline (OS_EMUL_INLINE)); |
| 156 | printf_filtered ("SUPPORT_INLINE = %s\n", options_inline (SUPPORT_INLINE)); |
| 157 | |
| 158 | #ifdef OPCODE_RULES |
| 159 | printf_filtered ("OPCODE rules = %s\n", OPCODE_RULES); |
| 160 | #endif |
| 161 | |
| 162 | #ifdef IGEN_FLAGS |
| 163 | printf_filtered ("IGEN_FLAGS = %s\n", IGEN_FLAGS); |
| 164 | #endif |
| 165 | |
| 166 | #ifdef DGEN_FLAGS |
| 167 | printf_filtered ("DGEN_FLAGS = %s\n", DGEN_FLAGS); |
| 168 | #endif |
| 169 | |
| 170 | { |
| 171 | static const char *const defines[] = { |
| 172 | #ifdef __GNUC__ |
| 173 | "__GNUC__", |
| 174 | #endif |
| 175 | |
| 176 | #ifdef __STRICT_ANSI__ |
| 177 | "__STRICT_ANSI__", |
| 178 | #endif |
| 179 | |
| 180 | #ifdef __CHAR_UNSIGNED__ |
| 181 | "__CHAR_UNSIGNED__", |
| 182 | #endif |
| 183 | |
| 184 | #ifdef __OPTIMIZE__ |
| 185 | "__OPTIMIZE__", |
| 186 | #endif |
| 187 | |
| 188 | #ifdef STDC_HEADERS |
| 189 | "STDC_HEADERS", |
| 190 | #endif |
| 191 | |
| 192 | #include "defines.h" |
| 193 | |
| 194 | #ifdef HAVE_TERMIOS_CLINE |
| 195 | "HAVE_TERMIOS_CLINE", |
| 196 | #endif |
| 197 | |
| 198 | #ifdef HAVE_TERMIOS_STRUCTURE |
| 199 | "HAVE_TERMIOS_STRUCTURE", |
| 200 | #endif |
| 201 | |
| 202 | #ifdef HAVE_TERMIO_CLINE |
| 203 | "HAVE_TERMIO_CLINE", |
| 204 | #endif |
| 205 | |
| 206 | #ifdef HAVE_TERMIO_STRUCTURE |
| 207 | "HAVE_TERMIO_STRUCTURE", |
| 208 | #endif |
| 209 | |
| 210 | #ifdef HAVE_DEVZERO |
| 211 | "HAVE_DEVZERO", |
| 212 | #endif |
| 213 | }; |
| 214 | |
| 215 | int i; |
| 216 | int max_len = 0; |
| 217 | int cols; |
| 218 | |
| 219 | for (i = 0; i < ARRAY_SIZE (defines); i++) { |
| 220 | int len = strlen (defines[i]); |
| 221 | if (len > max_len) |
| 222 | max_len = len; |
| 223 | } |
| 224 | |
| 225 | cols = 78 / (max_len + 2); |
| 226 | if (cols < 0) |
| 227 | cols = 1; |
| 228 | |
| 229 | printf_filtered ("\n#defines:"); |
| 230 | for (i = 0; i < ARRAY_SIZE (defines); i++) { |
| 231 | const char *const prefix = ((i % cols) == 0) ? "\n" : ""; |
| 232 | printf_filtered ("%s %s%*s", prefix, defines[i], |
| 233 | (((i == ARRAY_SIZE (defines) - 1) |
| 234 | || (((i + 1) % cols) == 0)) |
| 235 | ? 0 |
| 236 | : max_len + 4 - strlen (defines[i])), |
| 237 | ""); |
| 238 | } |
| 239 | printf_filtered ("\n"); |
| 240 | } |
| 241 | } |
| 242 | |
| 243 | #endif /* _OPTIONS_C_ */ |