1 /* Miscellaneous simulator utilities.
2 Copyright (C) 1997-2018 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
5 This file is part of GDB, the GNU debugger.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "sim-assert.h"
31 #ifdef HAVE_SYS_TIME_H
32 #include <sys/time.h> /* needed by sys/resource.h */
35 #ifdef HAVE_SYS_RESOURCE_H
36 #include <sys/resource.h>
47 #include "libiberty.h"
49 #include "sim-utils.h"
51 /* Allocate zero filled memory with xcalloc - xcalloc aborts if the
55 zalloc (unsigned long size)
57 return xcalloc (1, size);
60 /* Allocate a sim_state struct. */
63 sim_state_alloc (SIM_OPEN_KIND kind,
64 host_callback *callback)
66 SIM_DESC sd = ZALLOC (struct sim_state);
68 STATE_MAGIC (sd) = SIM_MAGIC_NUMBER;
69 STATE_CALLBACK (sd) = callback;
70 STATE_OPEN_KIND (sd) = kind;
76 /* Initialize the back link from the cpu struct to the state struct. */
77 /* ??? I can envision a design where the state struct contains an array
78 of pointers to cpu structs, rather than an array of structs themselves.
79 Implementing this is trickier as one may not know what to allocate until
80 one has parsed the args. Parsing the args twice wouldn't be unreasonable,
81 IMHO. If the state struct ever does contain an array of pointers then we
83 ??? See also sim_post_argv_init*/
84 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
86 CPU_STATE (STATE_CPU (sd, cpu_nr)) = sd;
87 CPU_INDEX (STATE_CPU (sd, cpu_nr)) = cpu_nr;
99 /* Free a sim_state struct. */
102 sim_state_free (SIM_DESC sd)
104 ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
106 #ifdef SIM_STATE_FREE
113 /* Return a pointer to the cpu data for CPU_NAME, or NULL if not found. */
116 sim_cpu_lookup (SIM_DESC sd, const char *cpu_name)
120 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
121 if (strcmp (cpu_name, CPU_NAME (STATE_CPU (sd, i))) == 0)
122 return STATE_CPU (sd, i);
126 /* Return the prefix to use for a CPU specific message (typically an
130 sim_cpu_msg_prefix (sim_cpu *cpu)
132 #if MAX_NR_PROCESSORS == 1
140 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
142 int len = strlen (CPU_NAME (STATE_CPU (sd, i)));
146 prefix = (char *) xmalloc (maxlen + 5);
148 sprintf (prefix, "%s: ", CPU_NAME (cpu));
153 /* Cover fn to sim_io_eprintf. */
156 sim_io_eprintf_cpu (sim_cpu *cpu, const char *fmt, ...)
158 SIM_DESC sd = CPU_STATE (cpu);
162 sim_io_eprintf (sd, "%s", sim_cpu_msg_prefix (cpu));
163 sim_io_evprintf (sd, fmt, ap);
167 /* Turn VALUE into a string with commas. */
170 sim_add_commas (char *buf, int sizeof_buf, unsigned long value)
173 char *endbuf = buf + sizeof_buf - 1;
183 *--endbuf = (value % 10) + '0';
184 } while ((value /= 10) != 0);
189 /* Analyze PROG_NAME/PROG_BFD and set these fields in the state struct:
190 STATE_ARCHITECTURE, if not set already and can be determined from the bfd
197 PROG_NAME is the file name of the executable or NULL.
198 PROG_BFD is its bfd or NULL.
200 If both PROG_NAME and PROG_BFD are NULL, this function returns immediately.
201 If PROG_BFD is not NULL, PROG_NAME is ignored.
203 Implicit inputs: STATE_MY_NAME(sd), STATE_TARGET(sd),
204 STATE_ARCHITECTURE(sd).
206 A new bfd is created so the app isn't required to keep its copy of the
210 sim_analyze_program (SIM_DESC sd, const char *prog_name, bfd *prog_bfd)
213 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
215 if (prog_bfd != NULL)
217 if (prog_bfd == STATE_PROG_BFD (sd))
218 /* already analyzed */
221 /* duplicate needed, save the name of the file to be re-opened */
222 prog_name = bfd_get_filename (prog_bfd);
225 /* do we need to duplicate anything? */
226 if (prog_name == NULL)
229 /* open a new copy of the prog_bfd */
230 prog_bfd = bfd_openr (prog_name, STATE_TARGET (sd));
231 if (prog_bfd == NULL)
233 sim_io_eprintf (sd, "%s: can't open \"%s\": %s\n",
236 bfd_errmsg (bfd_get_error ()));
239 if (!bfd_check_format (prog_bfd, bfd_object))
241 sim_io_eprintf (sd, "%s: \"%s\" is not an object file: %s\n",
244 bfd_errmsg (bfd_get_error ()));
245 bfd_close (prog_bfd);
248 if (STATE_ARCHITECTURE (sd) != NULL)
249 bfd_set_arch_info (prog_bfd, STATE_ARCHITECTURE (sd));
252 if (bfd_get_arch (prog_bfd) != bfd_arch_unknown
253 && bfd_get_arch (prog_bfd) != bfd_arch_obscure)
255 STATE_ARCHITECTURE (sd) = bfd_get_arch_info (prog_bfd);
259 /* update the sim structure */
260 if (STATE_PROG_BFD (sd) != NULL)
261 bfd_close (STATE_PROG_BFD (sd));
262 STATE_PROG_BFD (sd) = prog_bfd;
263 STATE_START_ADDR (sd) = bfd_get_start_address (prog_bfd);
265 for (s = prog_bfd->sections; s; s = s->next)
266 if (strcmp (bfd_get_section_name (prog_bfd, s), ".text") == 0)
268 STATE_TEXT_SECTION (sd) = s;
269 STATE_TEXT_START (sd) = bfd_get_section_vma (prog_bfd, s);
270 STATE_TEXT_END (sd) = STATE_TEXT_START (sd) + bfd_section_size (prog_bfd, s);
274 bfd_cache_close (prog_bfd);
279 /* Simulator timing support. */
281 /* Called before sim_elapsed_time_since to get a reference point. */
284 sim_elapsed_time_get (void)
286 #ifdef HAVE_GETRUSAGE
287 struct rusage mytime;
288 if (getrusage (RUSAGE_SELF, &mytime) == 0)
289 return 1 + (SIM_ELAPSED_TIME) (((double) mytime.ru_utime.tv_sec * 1000) + (((double) mytime.ru_utime.tv_usec + 500) / 1000));
293 return 1 + (SIM_ELAPSED_TIME) time ((time_t) 0);
300 /* Return the elapsed time in milliseconds since START.
301 The actual time may be cpu usage (preferred) or wall clock. */
304 sim_elapsed_time_since (SIM_ELAPSED_TIME start)
306 #ifdef HAVE_GETRUSAGE
307 return sim_elapsed_time_get () - start;
310 return (sim_elapsed_time_get () - start) * 1000;
319 /* do_command but with printf style formatting of the arguments */
321 sim_do_commandf (SIM_DESC sd,
330 ret = vasprintf (&buf, fmt, ap);
335 sim_io_eprintf (sd, "%s: asprintf failed for `%s'\n",
336 STATE_MY_NAME (sd), fmt);
340 sim_do_command (sd, buf);
345 /* sim-basics.h defines a number of enumerations, convert each of them
346 to a string representation */
348 map_to_str (unsigned map)
352 case read_map: return "read";
353 case write_map: return "write";
354 case exec_map: return "exec";
355 case io_map: return "io";
359 sprintf (str, "(%ld)", (long) map);
366 access_to_str (unsigned access)
370 case access_invalid: return "invalid";
371 case access_read: return "read";
372 case access_write: return "write";
373 case access_exec: return "exec";
374 case access_io: return "io";
375 case access_read_write: return "read_write";
376 case access_read_exec: return "read_exec";
377 case access_write_exec: return "write_exec";
378 case access_read_write_exec: return "read_write_exec";
379 case access_read_io: return "read_io";
380 case access_write_io: return "write_io";
381 case access_read_write_io: return "read_write_io";
382 case access_exec_io: return "exec_io";
383 case access_read_exec_io: return "read_exec_io";
384 case access_write_exec_io: return "write_exec_io";
385 case access_read_write_exec_io: return "read_write_exec_io";
389 sprintf (str, "(%ld)", (long) access);
396 transfer_to_str (unsigned transfer)
400 case read_transfer: return "read";
401 case write_transfer: return "write";
402 default: return "(error)";