1 /* Miscellaneous simulator utilities.
2 Copyright (C) 1997, 1998, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support.
6 This file is part of GDB, the GNU debugger.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "sim-assert.h"
32 #ifdef HAVE_SYS_TIME_H
33 #include <sys/time.h> /* needed by sys/resource.h */
36 #ifdef HAVE_SYS_RESOURCE_H
37 #include <sys/resource.h>
48 #include "libiberty.h"
50 #include "sim-utils.h"
52 /* Global pointer to all state data.
54 struct sim_state *current_state;
56 /* Allocate zero filled memory with xcalloc - xcalloc aborts if the
60 zalloc (unsigned long size)
62 return xcalloc (1, size);
71 /* Allocate a sim_state struct. */
74 sim_state_alloc (SIM_OPEN_KIND kind,
75 host_callback *callback)
77 SIM_DESC sd = ZALLOC (struct sim_state);
79 STATE_MAGIC (sd) = SIM_MAGIC_NUMBER;
80 STATE_CALLBACK (sd) = callback;
81 STATE_OPEN_KIND (sd) = kind;
87 /* Initialize the back link from the cpu struct to the state struct. */
88 /* ??? I can envision a design where the state struct contains an array
89 of pointers to cpu structs, rather than an array of structs themselves.
90 Implementing this is trickier as one may not know what to allocate until
91 one has parsed the args. Parsing the args twice wouldn't be unreasonable,
92 IMHO. If the state struct ever does contain an array of pointers then we
94 ??? See also sim_post_argv_init*/
95 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
97 CPU_STATE (STATE_CPU (sd, cpu_nr)) = sd;
98 CPU_INDEX (STATE_CPU (sd, cpu_nr)) = cpu_nr;
103 #ifdef SIM_STATE_INIT
110 /* Free a sim_state struct. */
113 sim_state_free (SIM_DESC sd)
115 ASSERT (sd->base.magic == SIM_MAGIC_NUMBER);
117 #ifdef SIM_STATE_FREE
124 /* Return a pointer to the cpu data for CPU_NAME, or NULL if not found. */
127 sim_cpu_lookup (SIM_DESC sd, const char *cpu_name)
131 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
132 if (strcmp (cpu_name, CPU_NAME (STATE_CPU (sd, i))) == 0)
133 return STATE_CPU (sd, i);
137 /* Return the prefix to use for a CPU specific message (typically an
141 sim_cpu_msg_prefix (sim_cpu *cpu)
143 #if MAX_NR_PROCESSORS == 1
151 for (i = 0; i < MAX_NR_PROCESSORS; ++i)
153 int len = strlen (CPU_NAME (STATE_CPU (sd, i)));
157 prefix = (char *) xmalloc (maxlen + 5);
159 sprintf (prefix, "%s: ", CPU_NAME (cpu));
164 /* Cover fn to sim_io_eprintf. */
167 sim_io_eprintf_cpu (sim_cpu *cpu, const char *fmt, ...)
169 SIM_DESC sd = CPU_STATE (cpu);
173 sim_io_eprintf (sd, "%s", sim_cpu_msg_prefix (cpu));
174 sim_io_evprintf (sd, fmt, ap);
178 /* Turn VALUE into a string with commas. */
181 sim_add_commas (char *buf, int sizeof_buf, unsigned long value)
184 char *endbuf = buf + sizeof_buf - 1;
194 *--endbuf = (value % 10) + '0';
195 } while ((value /= 10) != 0);
200 /* Analyze PROG_NAME/PROG_BFD and set these fields in the state struct:
201 STATE_ARCHITECTURE, if not set already and can be determined from the bfd
208 PROG_NAME is the file name of the executable or NULL.
209 PROG_BFD is its bfd or NULL.
211 If both PROG_NAME and PROG_BFD are NULL, this function returns immediately.
212 If PROG_BFD is not NULL, PROG_NAME is ignored.
214 Implicit inputs: STATE_MY_NAME(sd), STATE_TARGET(sd),
215 STATE_ARCHITECTURE(sd).
217 A new bfd is created so the app isn't required to keep its copy of the
221 sim_analyze_program (SIM_DESC sd, char *prog_name, bfd *prog_bfd)
224 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
226 if (prog_bfd != NULL)
228 if (prog_bfd == STATE_PROG_BFD (sd))
229 /* already analyzed */
232 /* duplicate needed, save the name of the file to be re-opened */
233 prog_name = bfd_get_filename (prog_bfd);
236 /* do we need to duplicate anything? */
237 if (prog_name == NULL)
240 /* open a new copy of the prog_bfd */
241 prog_bfd = bfd_openr (prog_name, STATE_TARGET (sd));
242 if (prog_bfd == NULL)
244 sim_io_eprintf (sd, "%s: can't open \"%s\": %s\n",
247 bfd_errmsg (bfd_get_error ()));
250 if (!bfd_check_format (prog_bfd, bfd_object))
252 sim_io_eprintf (sd, "%s: \"%s\" is not an object file: %s\n",
255 bfd_errmsg (bfd_get_error ()));
256 bfd_close (prog_bfd);
259 if (STATE_ARCHITECTURE (sd) != NULL)
260 bfd_set_arch_info (prog_bfd, STATE_ARCHITECTURE (sd));
263 if (bfd_get_arch (prog_bfd) != bfd_arch_unknown
264 && bfd_get_arch (prog_bfd) != bfd_arch_obscure)
266 STATE_ARCHITECTURE (sd) = bfd_get_arch_info (prog_bfd);
270 /* update the sim structure */
271 if (STATE_PROG_BFD (sd) != NULL)
272 bfd_close (STATE_PROG_BFD (sd));
273 STATE_PROG_BFD (sd) = prog_bfd;
274 STATE_START_ADDR (sd) = bfd_get_start_address (prog_bfd);
276 for (s = prog_bfd->sections; s; s = s->next)
277 if (strcmp (bfd_get_section_name (prog_bfd, s), ".text") == 0)
279 STATE_TEXT_SECTION (sd) = s;
280 STATE_TEXT_START (sd) = bfd_get_section_vma (prog_bfd, s);
281 STATE_TEXT_END (sd) = STATE_TEXT_START (sd) + bfd_section_size (prog_bfd, s);
285 bfd_cache_close (prog_bfd);
290 /* Simulator timing support. */
292 /* Called before sim_elapsed_time_since to get a reference point. */
295 sim_elapsed_time_get (void)
297 #ifdef HAVE_GETRUSAGE
298 struct rusage mytime;
299 if (getrusage (RUSAGE_SELF, &mytime) == 0)
300 return 1 + (SIM_ELAPSED_TIME) (((double) mytime.ru_utime.tv_sec * 1000) + (((double) mytime.ru_utime.tv_usec + 500) / 1000));
304 return 1 + (SIM_ELAPSED_TIME) time ((time_t) 0);
311 /* Return the elapsed time in milliseconds since START.
312 The actual time may be cpu usage (preferred) or wall clock. */
315 sim_elapsed_time_since (SIM_ELAPSED_TIME start)
317 #ifdef HAVE_GETRUSAGE
318 return sim_elapsed_time_get () - start;
321 return (sim_elapsed_time_get () - start) * 1000;
330 /* do_command but with printf style formatting of the arguments */
332 sim_do_commandf (SIM_DESC sd,
339 if (vasprintf (&buf, fmt, ap) < 0)
341 sim_io_eprintf (sd, "%s: asprintf failed for `%s'\n",
342 STATE_MY_NAME (sd), fmt);
345 sim_do_command (sd, buf);
351 /* sim-basics.h defines a number of enumerations, convert each of them
352 to a string representation */
354 map_to_str (unsigned map)
358 case read_map: return "read";
359 case write_map: return "write";
360 case exec_map: return "exec";
361 case io_map: return "io";
365 sprintf (str, "(%ld)", (long) map);
372 access_to_str (unsigned access)
376 case access_invalid: return "invalid";
377 case access_read: return "read";
378 case access_write: return "write";
379 case access_exec: return "exec";
380 case access_io: return "io";
381 case access_read_write: return "read_write";
382 case access_read_exec: return "read_exec";
383 case access_write_exec: return "write_exec";
384 case access_read_write_exec: return "read_write_exec";
385 case access_read_io: return "read_io";
386 case access_write_io: return "write_io";
387 case access_read_write_io: return "read_write_io";
388 case access_exec_io: return "exec_io";
389 case access_read_exec_io: return "read_exec_io";
390 case access_write_exec_io: return "write_exec_io";
391 case access_read_write_exec_io: return "read_write_exec_io";
395 sprintf (str, "(%ld)", (long) access);
402 transfer_to_str (unsigned transfer)
406 case read_transfer: return "read";
407 case write_transfer: return "write";
408 default: return "(error)";