1 /* The common simulator framework for GDB, the GNU Debugger. 2 3 Copyright 2002-2024 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 /* This must come before any other includes. */ 23 #include "defs.h" 24 25 #include "bfd.h" 26 27 #include "sim-main.h" 28 #include "sim-assert.h" 29 30 31 enum bfd_endian current_target_byte_order = BFD_ENDIAN_UNKNOWN; 32 int current_stdio; 33 34 enum sim_alignments current_alignment; 35 36 #if defined (WITH_FLOATING_POINT) 37 int current_floating_point; 38 #endif 39 40 41 42 /* map a byte order onto a textual string */ 43 44 static const char * 45 config_byte_order_to_a (enum bfd_endian byte_order) 46 { 47 switch (byte_order) 48 { 49 case BFD_ENDIAN_LITTLE: 50 return "LITTLE_ENDIAN"; 51 case BFD_ENDIAN_BIG: 52 return "BIG_ENDIAN"; 53 case BFD_ENDIAN_UNKNOWN: 54 return "UNKNOWN_ENDIAN"; 55 } 56 return "UNKNOWN"; 57 } 58 59 60 static const char * 61 config_stdio_to_a (int stdio) 62 { 63 switch (stdio) 64 { 65 case DONT_USE_STDIO: 66 return "DONT_USE_STDIO"; 67 case DO_USE_STDIO: 68 return "DO_USE_STDIO"; 69 case 0: 70 return "0"; 71 } 72 return "UNKNOWN"; 73 } 74 75 76 static const char * 77 config_environment_to_a (enum sim_environment environment) 78 { 79 switch (environment) 80 { 81 case ALL_ENVIRONMENT: 82 return "ALL_ENVIRONMENT"; 83 case USER_ENVIRONMENT: 84 return "USER_ENVIRONMENT"; 85 case VIRTUAL_ENVIRONMENT: 86 return "VIRTUAL_ENVIRONMENT"; 87 case OPERATING_ENVIRONMENT: 88 return "OPERATING_ENVIRONMENT"; 89 } 90 return "UNKNOWN"; 91 } 92 93 94 static const char * 95 config_alignment_to_a (enum sim_alignments alignment) 96 { 97 switch (alignment) 98 { 99 case MIXED_ALIGNMENT: 100 return "MIXED_ALIGNMENT"; 101 case NONSTRICT_ALIGNMENT: 102 return "NONSTRICT_ALIGNMENT"; 103 case STRICT_ALIGNMENT: 104 return "STRICT_ALIGNMENT"; 105 case FORCED_ALIGNMENT: 106 return "FORCED_ALIGNMENT"; 107 } 108 return "UNKNOWN"; 109 } 110 111 112 #if defined (WITH_FLOATING_POINT) 113 static const char * 114 config_floating_point_to_a (int floating_point) 115 { 116 switch (floating_point) 117 { 118 case SOFT_FLOATING_POINT: 119 return "SOFT_FLOATING_POINT"; 120 case HARD_FLOATING_POINT: 121 return "HARD_FLOATING_POINT"; 122 case 0: 123 return "0"; 124 } 125 return "UNKNOWN"; 126 } 127 #endif 128 129 /* Set the default environment, prior to parsing argv. */ 130 131 void 132 sim_config_default (SIM_DESC sd) 133 { 134 /* Set the current environment to ALL_ENVIRONMENT to indicate none has been 135 selected yet. This is so that after parsing argv, we know whether the 136 environment was explicitly specified or not. */ 137 STATE_ENVIRONMENT (sd) = ALL_ENVIRONMENT; 138 } 139 140 /* Complete and verify the simulation environment. */ 141 142 SIM_RC 143 sim_config (SIM_DESC sd) 144 { 145 enum bfd_endian prefered_target_byte_order; 146 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 147 148 /* extract all relevant information */ 149 if (STATE_PROG_BFD (sd) == NULL 150 /* If we have a binary input file (presumably with specified 151 "--architecture"), it'll have no endianness. */ 152 || (!bfd_little_endian (STATE_PROG_BFD (sd)) 153 && !bfd_big_endian (STATE_PROG_BFD (sd)))) 154 prefered_target_byte_order = BFD_ENDIAN_UNKNOWN; 155 else 156 prefered_target_byte_order = (bfd_little_endian (STATE_PROG_BFD (sd)) 157 ? BFD_ENDIAN_LITTLE 158 : BFD_ENDIAN_BIG); 159 160 /* set the target byte order */ 161 #if (WITH_TREE_PROPERTIES) 162 if (current_target_byte_order == BFD_ENDIAN_UNKNOWN) 163 current_target_byte_order 164 = (tree_find_boolean_property (root, "/options/little-endian?") 165 ? BFD_ENDIAN_LITTLE 166 : BFD_ENDIAN_BIG); 167 #endif 168 if (current_target_byte_order == BFD_ENDIAN_UNKNOWN 169 && prefered_target_byte_order != BFD_ENDIAN_UNKNOWN) 170 current_target_byte_order = prefered_target_byte_order; 171 if (current_target_byte_order == BFD_ENDIAN_UNKNOWN) 172 current_target_byte_order = WITH_TARGET_BYTE_ORDER; 173 174 /* verify the target byte order */ 175 if (CURRENT_TARGET_BYTE_ORDER == BFD_ENDIAN_UNKNOWN) 176 { 177 sim_io_eprintf (sd, "Target byte order unspecified\n"); 178 return SIM_RC_FAIL; 179 } 180 if (CURRENT_TARGET_BYTE_ORDER != current_target_byte_order) 181 sim_io_eprintf (sd, "Target (%s) and configured (%s) byte order in conflict\n", 182 config_byte_order_to_a (current_target_byte_order), 183 config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER)); 184 if (prefered_target_byte_order != BFD_ENDIAN_UNKNOWN 185 && CURRENT_TARGET_BYTE_ORDER != prefered_target_byte_order) 186 sim_io_eprintf (sd, "Target (%s) and specified (%s) byte order in conflict\n", 187 config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER), 188 config_byte_order_to_a (prefered_target_byte_order)); 189 190 191 /* set the stdio */ 192 if (current_stdio == 0) 193 current_stdio = WITH_STDIO; 194 if (current_stdio == 0) 195 current_stdio = DO_USE_STDIO; 196 197 /* verify the stdio */ 198 if (CURRENT_STDIO == 0) 199 { 200 sim_io_eprintf (sd, "Target standard IO unspecified\n"); 201 return SIM_RC_FAIL; 202 } 203 if (CURRENT_STDIO != current_stdio) 204 { 205 sim_io_eprintf (sd, "Target (%s) and configured (%s) standard IO in conflict\n", 206 config_stdio_to_a (CURRENT_STDIO), 207 config_stdio_to_a (current_stdio)); 208 return SIM_RC_FAIL; 209 } 210 211 212 /* check the value of MSB */ 213 if (WITH_TARGET_WORD_MSB != 0 214 && WITH_TARGET_WORD_MSB != (WITH_TARGET_WORD_BITSIZE - 1)) 215 { 216 sim_io_eprintf (sd, "Target bitsize (%d) contradicts target most significant bit (%d)\n", 217 WITH_TARGET_WORD_BITSIZE, WITH_TARGET_WORD_MSB); 218 return SIM_RC_FAIL; 219 } 220 221 222 /* set the environment */ 223 #if (WITH_TREE_PROPERTIES) 224 if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT) 225 { 226 const char *env = 227 tree_find_string_property (root, "/openprom/options/env"); 228 STATE_ENVIRONMENT (sd) = ((strcmp (env, "user") == 0 229 || strcmp (env, "uea") == 0) 230 ? USER_ENVIRONMENT 231 : (strcmp (env, "virtual") == 0 232 || strcmp (env, "vea") == 0) 233 ? VIRTUAL_ENVIRONMENT 234 : (strcmp (env, "operating") == 0 235 || strcmp (env, "oea") == 0) 236 ? OPERATING_ENVIRONMENT 237 : ALL_ENVIRONMENT); 238 } 239 #endif 240 if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT) 241 STATE_ENVIRONMENT (sd) = (WITH_ENVIRONMENT != ALL_ENVIRONMENT ? 242 WITH_ENVIRONMENT : USER_ENVIRONMENT); 243 244 245 /* set the alignment */ 246 #if (WITH_TREE_PROPERTIES) 247 if (current_alignment == 0) 248 current_alignment = 249 (tree_find_boolean_property (root, "/openprom/options/strict-alignment?") 250 ? STRICT_ALIGNMENT 251 : NONSTRICT_ALIGNMENT); 252 #endif 253 if (current_alignment == 0) 254 current_alignment = WITH_ALIGNMENT; 255 /* If the port hasn't specified an alignment, default to not enforcing. */ 256 if (current_alignment == 0) 257 current_alignment = NONSTRICT_ALIGNMENT; 258 259 /* verify the alignment */ 260 if (CURRENT_ALIGNMENT == 0) 261 { 262 sim_io_eprintf (sd, "Target alignment unspecified\n"); 263 return SIM_RC_FAIL; 264 } 265 if (CURRENT_ALIGNMENT != current_alignment) 266 { 267 sim_io_eprintf (sd, "Target (%s) and configured (%s) alignment in conflict\n", 268 config_alignment_to_a (CURRENT_ALIGNMENT), 269 config_alignment_to_a (current_alignment)); 270 return SIM_RC_FAIL; 271 } 272 273 #if defined (WITH_FLOATING_POINT) 274 275 /* set the floating point */ 276 if (current_floating_point == 0) 277 current_floating_point = WITH_FLOATING_POINT; 278 279 /* verify the floating point */ 280 if (CURRENT_FLOATING_POINT == 0) 281 { 282 sim_io_eprintf (sd, "Target floating-point unspecified\n"); 283 return SIM_RC_FAIL; 284 } 285 if (CURRENT_FLOATING_POINT != current_floating_point) 286 { 287 sim_io_eprintf (sd, "Target (%s) and configured (%s) floating-point in conflict\n", 288 config_alignment_to_a (CURRENT_FLOATING_POINT), 289 config_alignment_to_a (current_floating_point)); 290 return SIM_RC_FAIL; 291 } 292 293 #endif 294 return SIM_RC_OK; 295 } 296 297 298 void 299 sim_config_print (SIM_DESC sd) 300 { 301 sim_io_printf (sd, "WITH_TARGET_BYTE_ORDER = %s\n", 302 config_byte_order_to_a (WITH_TARGET_BYTE_ORDER)); 303 304 sim_io_printf (sd, "HOST_BYTE_ORDER = %s\n", 305 config_byte_order_to_a (HOST_BYTE_ORDER)); 306 307 sim_io_printf (sd, "WITH_STDIO = %s\n", 308 config_stdio_to_a (WITH_STDIO)); 309 310 sim_io_printf (sd, "WITH_TARGET_WORD_MSB = %d\n", 311 WITH_TARGET_WORD_MSB); 312 313 sim_io_printf (sd, "WITH_TARGET_WORD_BITSIZE = %d\n", 314 WITH_TARGET_WORD_BITSIZE); 315 316 sim_io_printf (sd, "WITH_TARGET_ADDRESS_BITSIZE = %d\n", 317 WITH_TARGET_ADDRESS_BITSIZE); 318 319 sim_io_printf (sd, "WITH_TARGET_CELL_BITSIZE = %d\n", 320 WITH_TARGET_CELL_BITSIZE); 321 322 sim_io_printf (sd, "WITH_TARGET_FLOATING_POINT_BITSIZE = %d\n", 323 WITH_TARGET_FLOATING_POINT_BITSIZE); 324 325 sim_io_printf (sd, "WITH_ENVIRONMENT = %s\n", 326 config_environment_to_a (WITH_ENVIRONMENT)); 327 328 sim_io_printf (sd, "WITH_ALIGNMENT = %s\n", 329 config_alignment_to_a (WITH_ALIGNMENT)); 330 331 #if defined (WITH_XOR_ENDIAN) 332 sim_io_printf (sd, "WITH_XOR_ENDIAN = %d\n", WITH_XOR_ENDIAN); 333 #endif 334 335 #if defined (WITH_FLOATING_POINT) 336 sim_io_printf (sd, "WITH_FLOATING_POINT = %s\n", 337 config_floating_point_to_a (WITH_FLOATING_POINT)); 338 #endif 339 340 #if defined (WITH_SMP) 341 sim_io_printf (sd, "WITH_SMP = %d\n", WITH_SMP); 342 #endif 343 344 #if defined (WITH_RESERVED_BITS) 345 sim_io_printf (sd, "WITH_RESERVED_BITS = %d\n", WITH_RESERVED_BITS); 346 #endif 347 348 #if defined (WITH_PROFILE) 349 sim_io_printf (sd, "WITH_PROFILE = %d\n", WITH_PROFILE); 350 #endif 351 352 } 353