1/* Miscellaneous simulator utilities.
2   Copyright (C) 1997, 1998, 2007, 2008, 2009, 2010, 2011
3   Free Software Foundation, Inc.
4   Contributed by Cygnus Support.
5
6This file is part of GDB, the GNU debugger.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 3 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21#include "sim-main.h"
22#include "sim-assert.h"
23
24#ifdef HAVE_STDLIB_H
25#include <stdlib.h>
26#endif
27
28#ifdef HAVE_TIME_H
29#include <time.h>
30#endif
31
32#ifdef HAVE_SYS_TIME_H
33#include <sys/time.h> /* needed by sys/resource.h */
34#endif
35
36#ifdef HAVE_SYS_RESOURCE_H
37#include <sys/resource.h>
38#endif
39
40#ifdef HAVE_STRING_H
41#include <string.h>
42#else
43#ifdef HAVE_STRINGS_H
44#include <strings.h>
45#endif
46#endif
47
48#include "libiberty.h"
49#include "bfd.h"
50#include "sim-utils.h"
51
52/* Global pointer to all state data.
53   Set by sim_resume.  */
54struct sim_state *current_state;
55
56/* Allocate zero filled memory with xcalloc - xcalloc aborts if the
57   allocation fails.  */
58
59void *
60zalloc (unsigned long size)
61{
62  return xcalloc (1, size);
63}
64
65/* Allocate a sim_state struct.  */
66
67SIM_DESC
68sim_state_alloc (SIM_OPEN_KIND kind,
69		 host_callback *callback)
70{
71  SIM_DESC sd = ZALLOC (struct sim_state);
72
73  STATE_MAGIC (sd) = SIM_MAGIC_NUMBER;
74  STATE_CALLBACK (sd) = callback;
75  STATE_OPEN_KIND (sd) = kind;
76
77#if 0
78  {
79    int cpu_nr;
80
81    /* Initialize the back link from the cpu struct to the state struct.  */
82    /* ??? I can envision a design where the state struct contains an array
83       of pointers to cpu structs, rather than an array of structs themselves.
84       Implementing this is trickier as one may not know what to allocate until
85       one has parsed the args.  Parsing the args twice wouldn't be unreasonable,
86       IMHO.  If the state struct ever does contain an array of pointers then we
87       can't do this here.
88       ??? See also sim_post_argv_init*/
89    for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
90      {
91	CPU_STATE (STATE_CPU (sd, cpu_nr)) = sd;
92	CPU_INDEX (STATE_CPU (sd, cpu_nr)) = cpu_nr;
93      }
94  }
95#endif
96
97#ifdef SIM_STATE_INIT
98  SIM_STATE_INIT (sd);
99#endif
100
101  return sd;
102}
103
104/* Free a sim_state struct.  */
105
106void
107sim_state_free (SIM_DESC sd)
108{
109  ASSERT (sd->base.magic == SIM_MAGIC_NUMBER);
110
111#ifdef SIM_STATE_FREE
112  SIM_STATE_FREE (sd);
113#endif
114
115  free (sd);
116}
117
118/* Return a pointer to the cpu data for CPU_NAME, or NULL if not found.  */
119
120sim_cpu *
121sim_cpu_lookup (SIM_DESC sd, const char *cpu_name)
122{
123  int i;
124
125  for (i = 0; i < MAX_NR_PROCESSORS; ++i)
126    if (strcmp (cpu_name, CPU_NAME (STATE_CPU (sd, i))) == 0)
127      return STATE_CPU (sd, i);
128  return NULL;
129}
130
131/* Return the prefix to use for a CPU specific message (typically an
132   error message).  */
133
134const char *
135sim_cpu_msg_prefix (sim_cpu *cpu)
136{
137#if MAX_NR_PROCESSORS == 1
138  return "";
139#else
140  static char *prefix;
141
142  if (prefix == NULL)
143    {
144      int maxlen = 0;
145      for (i = 0; i < MAX_NR_PROCESSORS; ++i)
146	{
147	  int len = strlen (CPU_NAME (STATE_CPU (sd, i)));
148	  if (len > maxlen)
149	    maxlen = len;
150	}
151      prefix = (char *) xmalloc (maxlen + 5);
152    }
153  sprintf (prefix, "%s: ", CPU_NAME (cpu));
154  return prefix;
155#endif
156}
157
158/* Cover fn to sim_io_eprintf.  */
159
160void
161sim_io_eprintf_cpu (sim_cpu *cpu, const char *fmt, ...)
162{
163  SIM_DESC sd = CPU_STATE (cpu);
164  va_list ap;
165
166  va_start (ap, fmt);
167  sim_io_eprintf (sd, "%s", sim_cpu_msg_prefix (cpu));
168  sim_io_evprintf (sd, fmt, ap);
169  va_end (ap);
170}
171
172/* Turn VALUE into a string with commas.  */
173
174char *
175sim_add_commas (char *buf, int sizeof_buf, unsigned long value)
176{
177  int comma = 3;
178  char *endbuf = buf + sizeof_buf - 1;
179
180  *--endbuf = '\0';
181  do {
182    if (comma-- == 0)
183      {
184	*--endbuf = ',';
185	comma = 2;
186      }
187
188    *--endbuf = (value % 10) + '0';
189  } while ((value /= 10) != 0);
190
191  return endbuf;
192}
193
194/* Analyze PROG_NAME/PROG_BFD and set these fields in the state struct:
195   STATE_ARCHITECTURE, if not set already and can be determined from the bfd
196   STATE_PROG_BFD
197   STATE_START_ADDR
198   STATE_TEXT_SECTION
199   STATE_TEXT_START
200   STATE_TEXT_END
201
202   PROG_NAME is the file name of the executable or NULL.
203   PROG_BFD is its bfd or NULL.
204
205   If both PROG_NAME and PROG_BFD are NULL, this function returns immediately.
206   If PROG_BFD is not NULL, PROG_NAME is ignored.
207
208   Implicit inputs: STATE_MY_NAME(sd), STATE_TARGET(sd),
209                    STATE_ARCHITECTURE(sd).
210
211   A new bfd is created so the app isn't required to keep its copy of the
212   bfd open.  */
213
214SIM_RC
215sim_analyze_program (SIM_DESC sd, char *prog_name, bfd *prog_bfd)
216{
217  asection *s;
218  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
219
220  if (prog_bfd != NULL)
221    {
222      if (prog_bfd == STATE_PROG_BFD (sd))
223	/* already analyzed */
224	return SIM_RC_OK;
225      else
226	/* duplicate needed, save the name of the file to be re-opened */
227	prog_name = bfd_get_filename (prog_bfd);
228    }
229
230  /* do we need to duplicate anything? */
231  if (prog_name == NULL)
232    return SIM_RC_OK;
233
234  /* open a new copy of the prog_bfd */
235  prog_bfd = bfd_openr (prog_name, STATE_TARGET (sd));
236  if (prog_bfd == NULL)
237    {
238      sim_io_eprintf (sd, "%s: can't open \"%s\": %s\n",
239		      STATE_MY_NAME (sd),
240		      prog_name,
241		      bfd_errmsg (bfd_get_error ()));
242      return SIM_RC_FAIL;
243    }
244  if (!bfd_check_format (prog_bfd, bfd_object))
245    {
246      sim_io_eprintf (sd, "%s: \"%s\" is not an object file: %s\n",
247		      STATE_MY_NAME (sd),
248		      prog_name,
249		      bfd_errmsg (bfd_get_error ()));
250      bfd_close (prog_bfd);
251      return SIM_RC_FAIL;
252    }
253  if (STATE_ARCHITECTURE (sd) != NULL)
254    bfd_set_arch_info (prog_bfd, STATE_ARCHITECTURE (sd));
255  else
256    {
257      if (bfd_get_arch (prog_bfd) != bfd_arch_unknown
258	  && bfd_get_arch (prog_bfd) != bfd_arch_obscure)
259	{
260	  STATE_ARCHITECTURE (sd) = bfd_get_arch_info (prog_bfd);
261	}
262    }
263
264  /* update the sim structure */
265  if (STATE_PROG_BFD (sd) != NULL)
266    bfd_close (STATE_PROG_BFD (sd));
267  STATE_PROG_BFD (sd) = prog_bfd;
268  STATE_START_ADDR (sd) = bfd_get_start_address (prog_bfd);
269
270  for (s = prog_bfd->sections; s; s = s->next)
271    if (strcmp (bfd_get_section_name (prog_bfd, s), ".text") == 0)
272      {
273	STATE_TEXT_SECTION (sd) = s;
274	STATE_TEXT_START (sd) = bfd_get_section_vma (prog_bfd, s);
275	STATE_TEXT_END (sd) = STATE_TEXT_START (sd) + bfd_section_size (prog_bfd, s);
276	break;
277      }
278
279  bfd_cache_close (prog_bfd);
280
281  return SIM_RC_OK;
282}
283
284/* Simulator timing support.  */
285
286/* Called before sim_elapsed_time_since to get a reference point.  */
287
288SIM_ELAPSED_TIME
289sim_elapsed_time_get (void)
290{
291#ifdef HAVE_GETRUSAGE
292  struct rusage mytime;
293  if (getrusage (RUSAGE_SELF, &mytime) == 0)
294    return 1 + (SIM_ELAPSED_TIME) (((double) mytime.ru_utime.tv_sec * 1000) + (((double) mytime.ru_utime.tv_usec + 500) / 1000));
295  return 1;
296#else
297#ifdef HAVE_TIME
298  return 1 + (SIM_ELAPSED_TIME) time ((time_t) 0);
299#else
300  return 1;
301#endif
302#endif
303}
304
305/* Return the elapsed time in milliseconds since START.
306   The actual time may be cpu usage (preferred) or wall clock.  */
307
308unsigned long
309sim_elapsed_time_since (SIM_ELAPSED_TIME start)
310{
311#ifdef HAVE_GETRUSAGE
312  return sim_elapsed_time_get () - start;
313#else
314#ifdef HAVE_TIME
315  return (sim_elapsed_time_get () - start) * 1000;
316#else
317  return 0;
318#endif
319#endif
320}
321
322
323
324/* do_command but with printf style formatting of the arguments */
325void
326sim_do_commandf (SIM_DESC sd,
327		 const char *fmt,
328		 ...)
329{
330  va_list ap;
331  char *buf;
332  va_start (ap, fmt);
333  if (vasprintf (&buf, fmt, ap) < 0)
334    {
335      sim_io_eprintf (sd, "%s: asprintf failed for `%s'\n",
336		      STATE_MY_NAME (sd), fmt);
337      return;
338    }
339  sim_do_command (sd, buf);
340  va_end (ap);
341  free (buf);
342}
343
344
345/* sim-basics.h defines a number of enumerations, convert each of them
346   to a string representation */
347const char *
348map_to_str (unsigned map)
349{
350  switch (map)
351    {
352    case read_map: return "read";
353    case write_map: return "write";
354    case exec_map: return "exec";
355    case io_map: return "io";
356    default:
357      {
358	static char str[10];
359	sprintf (str, "(%ld)", (long) map);
360	return str;
361      }
362    }
363}
364
365const char *
366access_to_str (unsigned access)
367{
368  switch (access)
369    {
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";
386    default:
387      {
388	static char str[10];
389	sprintf (str, "(%ld)", (long) access);
390	return str;
391      }
392    }
393}
394
395const char *
396transfer_to_str (unsigned transfer)
397{
398  switch (transfer)
399    {
400    case read_transfer: return "read";
401    case write_transfer: return "write";
402    default: return "(error)";
403    }
404}
405