[thirdparty/binutils-gdb.git] / sim / common / sim-utils.c

/* Miscellaneous simulator utilities.
   Copyright (C) 1997, 1998, 2007, 2008, 2009 Free Software Foundation, Inc.
   Contributed by Cygnus Support.

This file is part of GDB, the GNU debugger.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "sim-main.h"
#include "sim-assert.h"

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#ifdef HAVE_TIME_H
#include <time.h>
#endif

#ifdef HAVE_SYS_TIME_H
#include <sys/time.h> /* needed by sys/resource.h */
#endif

#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#endif

#include "libiberty.h"
#include "bfd.h"
#include "sim-utils.h"

/* Global pointer to all state data.
   Set by sim_resume.  */
struct sim_state *current_state;

/* Allocate zero filled memory with xmalloc - xmalloc aborts of the
   allocation fails.  */

void *
zalloc (unsigned long size)
{
  void *memory = (void *) xmalloc (size);
  memset (memory, 0, size);
  return memory;
}

void
zfree (void *data)
{
  free (data);
}

/* Allocate a sim_state struct.  */

SIM_DESC
sim_state_alloc (SIM_OPEN_KIND kind,
		 host_callback *callback)
{
  SIM_DESC sd = ZALLOC (struct sim_state);

  STATE_MAGIC (sd) = SIM_MAGIC_NUMBER;
  STATE_CALLBACK (sd) = callback;
  STATE_OPEN_KIND (sd) = kind;

#if 0
  {
    int cpu_nr;

    /* Initialize the back link from the cpu struct to the state struct.  */
    /* ??? I can envision a design where the state struct contains an array
       of pointers to cpu structs, rather than an array of structs themselves.
       Implementing this is trickier as one may not know what to allocate until
       one has parsed the args.  Parsing the args twice wouldn't be unreasonable,
       IMHO.  If the state struct ever does contain an array of pointers then we
       can't do this here.
       ??? See also sim_post_argv_init*/
    for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++)
      {
	CPU_STATE (STATE_CPU (sd, cpu_nr)) = sd;
	CPU_INDEX (STATE_CPU (sd, cpu_nr)) = cpu_nr;
      }
  }
#endif

#ifdef SIM_STATE_INIT
  SIM_STATE_INIT (sd);
#endif

  return sd;
}

/* Free a sim_state struct.  */

void
sim_state_free (SIM_DESC sd)
{
  ASSERT (sd->base.magic == SIM_MAGIC_NUMBER);

#ifdef SIM_STATE_FREE
  SIM_STATE_FREE (sd);
#endif

  zfree (sd);
}

/* Return a pointer to the cpu data for CPU_NAME, or NULL if not found.  */

sim_cpu *
sim_cpu_lookup (SIM_DESC sd, const char *cpu_name)
{
  int i;

  for (i = 0; i < MAX_NR_PROCESSORS; ++i)
    if (strcmp (cpu_name, CPU_NAME (STATE_CPU (sd, i))) == 0)
      return STATE_CPU (sd, i);
  return NULL;
}

/* Return the prefix to use for a CPU specific message (typically an
   error message).  */

const char *
sim_cpu_msg_prefix (sim_cpu *cpu)
{
#if MAX_NR_PROCESSORS == 1
  return "";
#else
  static char *prefix;

  if (prefix == NULL)
    {
      int maxlen = 0;
      for (i = 0; i < MAX_NR_PROCESSORS; ++i)
	{
	  int len = strlen (CPU_NAME (STATE_CPU (sd, i)));
	  if (len > maxlen)
	    maxlen = len;
	}
      prefix = (char *) xmalloc (maxlen + 5);
    }
  sprintf (prefix, "%s: ", CPU_NAME (cpu));
  return prefix;
#endif
}

/* Cover fn to sim_io_eprintf.  */

void
sim_io_eprintf_cpu (sim_cpu *cpu, const char *fmt, ...)
{
  SIM_DESC sd = CPU_STATE (cpu);
  va_list ap;

  va_start (ap, fmt);
  sim_io_eprintf (sd, sim_cpu_msg_prefix (cpu));
  sim_io_evprintf (sd, fmt, ap);
  va_end (ap);
}

/* Turn VALUE into a string with commas.  */

char *
sim_add_commas (char *buf, int sizeof_buf, unsigned long value)
{
  int comma = 3;
  char *endbuf = buf + sizeof_buf - 1;

  *--endbuf = '\0';
  do {
    if (comma-- == 0)
      {
	*--endbuf = ',';
	comma = 2;
      }

    *--endbuf = (value % 10) + '0';
  } while ((value /= 10) != 0);

  return endbuf;
}

/* Analyze PROG_NAME/PROG_BFD and set these fields in the state struct:
   STATE_ARCHITECTURE, if not set already and can be determined from the bfd
   STATE_PROG_BFD
   STATE_START_ADDR
   STATE_TEXT_SECTION
   STATE_TEXT_START
   STATE_TEXT_END

   PROG_NAME is the file name of the executable or NULL.
   PROG_BFD is its bfd or NULL.

   If both PROG_NAME and PROG_BFD are NULL, this function returns immediately.
   If PROG_BFD is not NULL, PROG_NAME is ignored.

   Implicit inputs: STATE_MY_NAME(sd), STATE_TARGET(sd),
                    STATE_ARCHITECTURE(sd).

   A new bfd is created so the app isn't required to keep its copy of the
   bfd open.  */

SIM_RC
sim_analyze_program (sd, prog_name, prog_bfd)
     SIM_DESC sd;
     char *prog_name;
     bfd *prog_bfd;
{
  asection *s;
  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);

  if (prog_bfd != NULL)
    {
      if (prog_bfd == STATE_PROG_BFD (sd))
	/* already analyzed */
	return SIM_RC_OK;
      else
	/* duplicate needed, save the name of the file to be re-opened */
	prog_name = bfd_get_filename (prog_bfd);
    }

  /* do we need to duplicate anything? */
  if (prog_name == NULL)
    return SIM_RC_OK;

  /* open a new copy of the prog_bfd */
  prog_bfd = bfd_openr (prog_name, STATE_TARGET (sd));
  if (prog_bfd == NULL)
    {
      sim_io_eprintf (sd, "%s: can't open \"%s\": %s\n", 
		      STATE_MY_NAME (sd),
		      prog_name,
		      bfd_errmsg (bfd_get_error ()));
      return SIM_RC_FAIL;
    }
  if (!bfd_check_format (prog_bfd, bfd_object)) 
    {
      sim_io_eprintf (sd, "%s: \"%s\" is not an object file: %s\n",
		      STATE_MY_NAME (sd),
		      prog_name,
		      bfd_errmsg (bfd_get_error ()));
      bfd_close (prog_bfd);
      return SIM_RC_FAIL;
    }
  if (STATE_ARCHITECTURE (sd) != NULL)
    bfd_set_arch_info (prog_bfd, STATE_ARCHITECTURE (sd));
  else
    {
      if (bfd_get_arch (prog_bfd) != bfd_arch_unknown
	  && bfd_get_arch (prog_bfd) != bfd_arch_obscure)
	{
	  STATE_ARCHITECTURE (sd) = bfd_get_arch_info (prog_bfd);
	}
    }

  /* update the sim structure */
  if (STATE_PROG_BFD (sd) != NULL)
    bfd_close (STATE_PROG_BFD (sd));
  STATE_PROG_BFD (sd) = prog_bfd;
  STATE_START_ADDR (sd) = bfd_get_start_address (prog_bfd);

  for (s = prog_bfd->sections; s; s = s->next)
    if (strcmp (bfd_get_section_name (prog_bfd, s), ".text") == 0)
      {
	STATE_TEXT_SECTION (sd) = s;
	STATE_TEXT_START (sd) = bfd_get_section_vma (prog_bfd, s);
	STATE_TEXT_END (sd) = STATE_TEXT_START (sd) + bfd_section_size (prog_bfd, s);
	break;
      }

  bfd_cache_close (prog_bfd);

  return SIM_RC_OK;
}
\f
/* Simulator timing support.  */

/* Called before sim_elapsed_time_since to get a reference point.  */

SIM_ELAPSED_TIME
sim_elapsed_time_get ()
{
#ifdef HAVE_GETRUSAGE
  struct rusage mytime;
  if (getrusage (RUSAGE_SELF, &mytime) == 0)
    return 1 + (SIM_ELAPSED_TIME) (((double) mytime.ru_utime.tv_sec * 1000) + (((double) mytime.ru_utime.tv_usec + 500) / 1000));
  return 1;
#else
#ifdef HAVE_TIME
  return 1 + (SIM_ELAPSED_TIME) time ((time_t) 0);
#else
  return 1;
#endif
#endif
}

/* Return the elapsed time in milliseconds since START.
   The actual time may be cpu usage (preferred) or wall clock.  */

unsigned long
sim_elapsed_time_since (start)
     SIM_ELAPSED_TIME start;
{
#ifdef HAVE_GETRUSAGE
  return sim_elapsed_time_get () - start;
#else
#ifdef HAVE_TIME
  return (sim_elapsed_time_get () - start) * 1000;
#else
  return 0;
#endif
#endif
}


/* do_command but with printf style formatting of the arguments */
void
sim_do_commandf (SIM_DESC sd,
		 const char *fmt,
		 ...)
{
  va_list ap;
  char *buf;
  va_start (ap, fmt);
  vasprintf (&buf, fmt, ap);
  sim_do_command (sd, buf);
  va_end (ap);
  free (buf);
}


/* sim-basics.h defines a number of enumerations, convert each of them
   to a string representation */
const char *
map_to_str (unsigned map)
{
  switch (map)
    {
    case read_map: return "read";
    case write_map: return "write";
    case exec_map: return "exec";
    case io_map: return "io";
    default:
      {
	static char str[10];
	sprintf (str, "(%ld)", (long) map);
	return str;
      }
    }
}

const char *
access_to_str (unsigned access)
{
  switch (access)
    {
    case access_invalid: return "invalid";
    case access_read: return "read";
    case access_write: return "write";
    case access_exec: return "exec";
    case access_io: return "io";
    case access_read_write: return "read_write";
    case access_read_exec: return "read_exec";
    case access_write_exec: return "write_exec";
    case access_read_write_exec: return "read_write_exec";
    case access_read_io: return "read_io";
    case access_write_io: return "write_io";
    case access_read_write_io: return "read_write_io";
    case access_exec_io: return "exec_io";
    case access_read_exec_io: return "read_exec_io";
    case access_write_exec_io: return "write_exec_io";
    case access_read_write_exec_io: return "read_write_exec_io";
    default:
      {
	static char str[10];
	sprintf (str, "(%ld)", (long) access);
	return str;
      }
    }
}

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