[binutils, ARM, 5/16] BF insns infrastructure with new global reloc R_ARM_THM_BF16
[binutils-gdb.git] / sim / common / sim-config.c
blob65dcef90f3ef0a14a2a39feb0b6c3ab0218ea57a
1 /* The common simulator framework for GDB, the GNU Debugger.
3 Copyright 2002-2019 Free Software Foundation, Inc.
5 Contributed by Andrew Cagney and Red Hat.
7 This file is part of GDB.
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.
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.
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/>. */
23 #include "sim-main.h"
24 #include "sim-assert.h"
25 #include "bfd.h"
28 enum bfd_endian current_target_byte_order = BFD_ENDIAN_UNKNOWN;
29 int current_stdio;
31 enum sim_alignments current_alignment;
33 #if defined (WITH_FLOATING_POINT)
34 int current_floating_point;
35 #endif
39 /* map a byte order onto a textual string */
41 static const char *
42 config_byte_order_to_a (enum bfd_endian byte_order)
44 switch (byte_order)
46 case BFD_ENDIAN_LITTLE:
47 return "LITTLE_ENDIAN";
48 case BFD_ENDIAN_BIG:
49 return "BIG_ENDIAN";
50 case BFD_ENDIAN_UNKNOWN:
51 return "UNKNOWN_ENDIAN";
53 return "UNKNOWN";
57 static const char *
58 config_stdio_to_a (int stdio)
60 switch (stdio)
62 case DONT_USE_STDIO:
63 return "DONT_USE_STDIO";
64 case DO_USE_STDIO:
65 return "DO_USE_STDIO";
66 case 0:
67 return "0";
69 return "UNKNOWN";
73 static const char *
74 config_environment_to_a (enum sim_environment environment)
76 switch (environment)
78 case ALL_ENVIRONMENT:
79 return "ALL_ENVIRONMENT";
80 case USER_ENVIRONMENT:
81 return "USER_ENVIRONMENT";
82 case VIRTUAL_ENVIRONMENT:
83 return "VIRTUAL_ENVIRONMENT";
84 case OPERATING_ENVIRONMENT:
85 return "OPERATING_ENVIRONMENT";
87 return "UNKNOWN";
91 static const char *
92 config_alignment_to_a (enum sim_alignments alignment)
94 switch (alignment)
96 case MIXED_ALIGNMENT:
97 return "MIXED_ALIGNMENT";
98 case NONSTRICT_ALIGNMENT:
99 return "NONSTRICT_ALIGNMENT";
100 case STRICT_ALIGNMENT:
101 return "STRICT_ALIGNMENT";
102 case FORCED_ALIGNMENT:
103 return "FORCED_ALIGNMENT";
105 return "UNKNOWN";
109 #if defined (WITH_FLOATING_POINT)
110 static const char *
111 config_floating_point_to_a (int floating_point)
113 switch (floating_point)
115 case SOFT_FLOATING_POINT:
116 return "SOFT_FLOATING_POINT";
117 case HARD_FLOATING_POINT:
118 return "HARD_FLOATING_POINT";
119 case 0:
120 return "0";
122 return "UNKNOWN";
124 #endif
126 /* Set the default environment, prior to parsing argv. */
128 void
129 sim_config_default (SIM_DESC sd)
131 /* Set the current environment to ALL_ENVIRONMENT to indicate none has been
132 selected yet. This is so that after parsing argv, we know whether the
133 environment was explicitly specified or not. */
134 STATE_ENVIRONMENT (sd) = ALL_ENVIRONMENT;
137 /* Complete and verify the simulation environment. */
139 SIM_RC
140 sim_config (SIM_DESC sd)
142 enum bfd_endian prefered_target_byte_order;
143 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
145 /* extract all relevant information */
146 if (STATE_PROG_BFD (sd) == NULL
147 /* If we have a binary input file (presumably with specified
148 "--architecture"), it'll have no endianness. */
149 || (!bfd_little_endian (STATE_PROG_BFD (sd))
150 && !bfd_big_endian (STATE_PROG_BFD (sd))))
151 prefered_target_byte_order = BFD_ENDIAN_UNKNOWN;
152 else
153 prefered_target_byte_order = (bfd_little_endian (STATE_PROG_BFD (sd))
154 ? BFD_ENDIAN_LITTLE
155 : BFD_ENDIAN_BIG);
157 /* set the target byte order */
158 #if (WITH_TREE_PROPERTIES)
159 if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
160 current_target_byte_order
161 = (tree_find_boolean_property (root, "/options/little-endian?")
162 ? BFD_ENDIAN_LITTLE
163 : BFD_ENDIAN_BIG);
164 #endif
165 if (current_target_byte_order == BFD_ENDIAN_UNKNOWN
166 && prefered_target_byte_order != BFD_ENDIAN_UNKNOWN)
167 current_target_byte_order = prefered_target_byte_order;
168 if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
169 current_target_byte_order = WITH_TARGET_BYTE_ORDER;
170 if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
171 current_target_byte_order = WITH_DEFAULT_TARGET_BYTE_ORDER;
173 /* verify the target byte order */
174 if (CURRENT_TARGET_BYTE_ORDER == BFD_ENDIAN_UNKNOWN)
176 sim_io_eprintf (sd, "Target byte order unspecified\n");
177 return SIM_RC_FAIL;
179 if (CURRENT_TARGET_BYTE_ORDER != current_target_byte_order)
180 sim_io_eprintf (sd, "Target (%s) and configured (%s) byte order in conflict\n",
181 config_byte_order_to_a (current_target_byte_order),
182 config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER));
183 if (prefered_target_byte_order != BFD_ENDIAN_UNKNOWN
184 && CURRENT_TARGET_BYTE_ORDER != prefered_target_byte_order)
185 sim_io_eprintf (sd, "Target (%s) and specified (%s) byte order in conflict\n",
186 config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER),
187 config_byte_order_to_a (prefered_target_byte_order));
190 /* set the stdio */
191 if (current_stdio == 0)
192 current_stdio = WITH_STDIO;
193 if (current_stdio == 0)
194 current_stdio = DO_USE_STDIO;
196 /* verify the stdio */
197 if (CURRENT_STDIO == 0)
199 sim_io_eprintf (sd, "Target standard IO unspecified\n");
200 return SIM_RC_FAIL;
202 if (CURRENT_STDIO != current_stdio)
204 sim_io_eprintf (sd, "Target (%s) and configured (%s) standard IO in conflict\n",
205 config_stdio_to_a (CURRENT_STDIO),
206 config_stdio_to_a (current_stdio));
207 return SIM_RC_FAIL;
211 /* check the value of MSB */
212 if (WITH_TARGET_WORD_MSB != 0
213 && WITH_TARGET_WORD_MSB != (WITH_TARGET_WORD_BITSIZE - 1))
215 sim_io_eprintf (sd, "Target bitsize (%d) contradicts target most significant bit (%d)\n",
216 WITH_TARGET_WORD_BITSIZE, WITH_TARGET_WORD_MSB);
217 return SIM_RC_FAIL;
221 /* set the environment */
222 #if (WITH_TREE_PROPERTIES)
223 if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
225 const char *env =
226 tree_find_string_property (root, "/openprom/options/env");
227 STATE_ENVIRONMENT (sd) = ((strcmp (env, "user") == 0
228 || strcmp (env, "uea") == 0)
229 ? USER_ENVIRONMENT
230 : (strcmp (env, "virtual") == 0
231 || strcmp (env, "vea") == 0)
232 ? VIRTUAL_ENVIRONMENT
233 : (strcmp (env, "operating") == 0
234 || strcmp (env, "oea") == 0)
235 ? OPERATING_ENVIRONMENT
236 : ALL_ENVIRONMENT);
238 #endif
239 if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
240 STATE_ENVIRONMENT (sd) = (WITH_ENVIRONMENT != ALL_ENVIRONMENT ?
241 WITH_ENVIRONMENT : USER_ENVIRONMENT);
244 /* set the alignment */
245 #if (WITH_TREE_PROPERTIES)
246 if (current_alignment == 0)
247 current_alignment =
248 (tree_find_boolean_property (root, "/openprom/options/strict-alignment?")
249 ? STRICT_ALIGNMENT
250 : NONSTRICT_ALIGNMENT);
251 #endif
252 if (current_alignment == 0)
253 current_alignment = WITH_ALIGNMENT;
254 if (current_alignment == 0)
255 current_alignment = WITH_DEFAULT_ALIGNMENT;
257 /* verify the alignment */
258 if (CURRENT_ALIGNMENT == 0)
260 sim_io_eprintf (sd, "Target alignment unspecified\n");
261 return SIM_RC_FAIL;
263 if (CURRENT_ALIGNMENT != current_alignment)
265 sim_io_eprintf (sd, "Target (%s) and configured (%s) alignment in conflict\n",
266 config_alignment_to_a (CURRENT_ALIGNMENT),
267 config_alignment_to_a (current_alignment));
268 return SIM_RC_FAIL;
271 #if defined (WITH_FLOATING_POINT)
273 /* set the floating point */
274 if (current_floating_point == 0)
275 current_floating_point = WITH_FLOATING_POINT;
277 /* verify the floating point */
278 if (CURRENT_FLOATING_POINT == 0)
280 sim_io_eprintf (sd, "Target floating-point unspecified\n");
281 return SIM_RC_FAIL;
283 if (CURRENT_FLOATING_POINT != current_floating_point)
285 sim_io_eprintf (sd, "Target (%s) and configured (%s) floating-point in conflict\n",
286 config_alignment_to_a (CURRENT_FLOATING_POINT),
287 config_alignment_to_a (current_floating_point));
288 return SIM_RC_FAIL;
291 #endif
292 return SIM_RC_OK;
296 void
297 print_sim_config (SIM_DESC sd)
299 sim_io_printf (sd, "WITH_TARGET_BYTE_ORDER = %s\n",
300 config_byte_order_to_a (WITH_TARGET_BYTE_ORDER));
302 sim_io_printf (sd, "WITH_DEFAULT_TARGET_BYTE_ORDER = %s\n",
303 config_byte_order_to_a (WITH_DEFAULT_TARGET_BYTE_ORDER));
305 sim_io_printf (sd, "HOST_BYTE_ORDER = %s\n",
306 config_byte_order_to_a (HOST_BYTE_ORDER));
308 sim_io_printf (sd, "WITH_STDIO = %s\n",
309 config_stdio_to_a (WITH_STDIO));
311 sim_io_printf (sd, "WITH_TARGET_WORD_MSB = %d\n",
312 WITH_TARGET_WORD_MSB);
314 sim_io_printf (sd, "WITH_TARGET_WORD_BITSIZE = %d\n",
315 WITH_TARGET_WORD_BITSIZE);
317 sim_io_printf (sd, "WITH_TARGET_ADDRESS_BITSIZE = %d\n",
318 WITH_TARGET_ADDRESS_BITSIZE);
320 sim_io_printf (sd, "WITH_TARGET_CELL_BITSIZE = %d\n",
321 WITH_TARGET_CELL_BITSIZE);
323 sim_io_printf (sd, "WITH_TARGET_FLOATING_POINT_BITSIZE = %d\n",
324 WITH_TARGET_FLOATING_POINT_BITSIZE);
326 sim_io_printf (sd, "WITH_ENVIRONMENT = %s\n",
327 config_environment_to_a (WITH_ENVIRONMENT));
329 sim_io_printf (sd, "WITH_ALIGNMENT = %s\n",
330 config_alignment_to_a (WITH_ALIGNMENT));
332 #if defined (WITH_DEFAULT_ALIGNMENT)
333 sim_io_printf (sd, "WITH_DEFAULT_ALIGNMENT = %s\n",
334 config_alignment_to_a (WITH_DEFAULT_ALIGNMENT));
335 #endif
337 #if defined (WITH_XOR_ENDIAN)
338 sim_io_printf (sd, "WITH_XOR_ENDIAN = %d\n", WITH_XOR_ENDIAN);
339 #endif
341 #if defined (WITH_FLOATING_POINT)
342 sim_io_printf (sd, "WITH_FLOATING_POINT = %s\n",
343 config_floating_point_to_a (WITH_FLOATING_POINT));
344 #endif
346 #if defined (WITH_SMP)
347 sim_io_printf (sd, "WITH_SMP = %d\n", WITH_SMP);
348 #endif
350 #if defined (WITH_RESERVED_BITS)
351 sim_io_printf (sd, "WITH_RESERVED_BITS = %d\n", WITH_RESERVED_BITS);
352 #endif
354 #if defined (WITH_PROFILE)
355 sim_io_printf (sd, "WITH_PROFILE = %d\n", WITH_PROFILE);
356 #endif