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

/* New version of run front end support for simulators.
   Copyright (C) 1997-2025 Free Software Foundation, Inc.

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/>.  */

/* Need to be before general includes, to pick up e.g. _GNU_SOURCE.  */
#include "defs.h"

#include <signal.h>
#include <stdlib.h>
/* For strsignal.  */
#include <string.h>
/* For chdir.  */
#include <unistd.h>

#include "bfd.h"
#include "environ.h"

#include "sim-main.h"
#include "sim-signal.h"
#include "sim/callback.h"

#ifndef HAVE_STRSIGNAL
/* While libiberty provides a fallback, it doesn't provide a prototype.  */
extern const char *strsignal (int);
#endif

static void usage (void);

extern host_callback default_callback;

static const char *myname;

static SIM_DESC sd;

static void
cntrl_c (int sig)
{
  if (! sim_stop (sd))
    {
      fprintf (stderr, "Quit!\n");
      exit (1);
    }
}

int
main (int argc, char **argv)
{
  const char *name;
  char **prog_argv = NULL;
  char **prog_envp = NULL;
  struct bfd *prog_bfd;
  enum sim_stop reason;
  int sigrc = 0;
  int single_step = 0;
  void (*prev_sigint) (int);

  myname = lbasename (argv[0]);

  /* INTERNAL: When MYNAME is `step', single step the simulator
     instead of allowing it to run free.  The sole purpose of this
     HACK is to allow the sim_resume interface's step argument to be
     tested without having to build/run gdb. */
  if (strlen (myname) > 4 && strcmp (myname - 4, "step") == 0)
    {
      single_step = 1;
    }

  /* Create an instance of the simulator.  */
  default_callback.init (&default_callback);
  sd = sim_open (SIM_OPEN_STANDALONE, &default_callback, NULL, argv);
  if (sd == 0)
    exit (1);
  if (STATE_MAGIC (sd) != SIM_MAGIC_NUMBER)
    {
      fprintf (stderr, "Internal error - bad magic number in simulator struct\n");
      abort ();
    }

  /* We can't set the endianness in the callback structure until sim_config is
     called, which happens in sim_open.  If it's still the default, switch it.
     Don't use CURRENT_TARGET_BYTE_ORDER as all its internal processing already
     happened in sim_config.  */
  if (default_callback.target_endian == BFD_ENDIAN_UNKNOWN)
    default_callback.target_endian = current_target_byte_order;

  /* Was there a program to run?  */
  prog_argv = STATE_PROG_ARGV (sd);
  prog_envp = STATE_PROG_ENVP (sd) ? : environ;
  prog_bfd = STATE_PROG_BFD (sd);
  if (prog_argv == NULL || *prog_argv == NULL)
    usage ();

  name = STATE_PROG_FILE (sd);

  /* For simulators that don't open prog during sim_open() */
  if (prog_bfd == NULL)
    {
      prog_bfd = bfd_openr (name, 0);
      if (prog_bfd == NULL)
	{
	  fprintf (stderr, "%s: can't open \"%s\": %s\n",
		   myname, name, bfd_errmsg (bfd_get_error ()));
	  exit (1);
	}
      if (!bfd_check_format (prog_bfd, bfd_object))
	{
	  fprintf (stderr, "%s: \"%s\" is not an object file: %s\n",
		   myname, name, bfd_errmsg (bfd_get_error ()));
	  exit (1);
	}
    }

  if (STATE_VERBOSE_P (sd))
    printf ("%s %s\n", myname, name);

  /* Load the program into the simulator.  */
  if (sim_load (sd, name, prog_bfd, 0) == SIM_RC_FAIL)
    exit (1);

  /* Prepare the program for execution.  */
  sim_create_inferior (sd, prog_bfd, prog_argv, prog_envp);

  /* To accommodate relative file paths, chdir to sysroot now.  We
     mustn't do this until BFD has opened the program, else we wouldn't
     find the executable if it has a relative file path.  */
  if (simulator_sysroot[0] != '\0' && chdir (simulator_sysroot) < 0)
    {
      fprintf (stderr, "%s: can't change directory to \"%s\"\n",
	       myname, simulator_sysroot);
      exit (1);
    }

  /* Run/Step the program.  */
  if (single_step)
    {
      do
	{
	  prev_sigint = signal (SIGINT, cntrl_c);
	  sim_resume (sd, 1/*step*/, 0);
	  signal (SIGINT, prev_sigint);
	  sim_stop_reason (sd, &reason, &sigrc);

	  if ((reason == sim_stopped) &&
	      (sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
	    break; /* exit on control-C */
	}
      /* remain on breakpoint or signals in oe mode*/
      while (((reason == sim_signalled) &&
	      (sigrc == sim_signal_to_host (sd, SIM_SIGTRAP))) ||
	     ((reason == sim_stopped) &&
	      (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)));
    }
  else
    {
      do
	{
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
	  struct sigaction sa, osa;
	  sa.sa_handler = cntrl_c;
	  sigemptyset (&sa.sa_mask);
	  sa.sa_flags = 0;
	  sigaction (SIGINT, &sa, &osa);
	  prev_sigint = osa.sa_handler;
#else
	  prev_sigint = signal (SIGINT, cntrl_c);
#endif
	  sim_resume (sd, 0, sigrc);
	  signal (SIGINT, prev_sigint);
	  sim_stop_reason (sd, &reason, &sigrc);

	  if ((reason == sim_stopped) &&
	      (sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
	    break; /* exit on control-C */

	  /* remain on signals in oe mode */
	} while ((reason == sim_stopped) &&
		 (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT));

    }
  /* Print any stats the simulator collected.  */
  if (STATE_VERBOSE_P (sd))
    sim_info (sd, 0);

  /* Shutdown the simulator.  */
  sim_close (sd, 0);

  /* If reason is sim_exited, then sigrc holds the exit code which we want
     to return.  If reason is sim_stopped or sim_signalled, then sigrc holds
     the signal that the simulator received; we want to return that to
     indicate failure.  */

  /* Why did we stop? */
  switch (reason)
    {
    case sim_signalled:
    case sim_stopped:
      if (sigrc != 0)
	fprintf (stderr, "program stopped with signal %d (%s).\n", sigrc,
		 strsignal (sigrc));
      break;

    case sim_exited:
      break;

    default:
      fprintf (stderr, "program in undefined state (%d:%d)\n", reason, sigrc);
      break;

    }

  return sigrc;
}

static void
usage (void)
{
  fprintf (stderr, "Usage: %s [options] [VAR=VAL|--] program [program args]\n",
	   myname);
  fprintf (stderr, "Run `%s --help' for full list of options.\n", myname);
  exit (1);
}
Commit	Line	Data
	1	/* New version of run front end support for simulators.
	2	Copyright (C) 1997-2025 Free Software Foundation, Inc.
	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 3 of the License, or
	7	(at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	16
	17	/* Need to be before general includes, to pick up e.g. _GNU_SOURCE. */
	18	#include "defs.h"
	19
	20	#include <signal.h>
	21	#include <stdlib.h>
	22	/* For strsignal. */
	23	#include <string.h>
	24	/* For chdir. */
	25	#include <unistd.h>
	26
	27	#include "bfd.h"
	28	#include "environ.h"
	29
	30	#include "sim-main.h"
	31	#include "sim-signal.h"
	32	#include "sim/callback.h"
	33
	34	#ifndef HAVE_STRSIGNAL
	35	/* While libiberty provides a fallback, it doesn't provide a prototype. */
	36	extern const char *strsignal (int);
	37	#endif
	38
	39	static void usage (void);
	40
	41	extern host_callback default_callback;
	42
	43	static const char *myname;
	44
	45	static SIM_DESC sd;
	46
	47	static void
	48	cntrl_c (int sig)
	49	{
	50	if (! sim_stop (sd))
	51	{
	52	fprintf (stderr, "Quit!\n");
	53	exit (1);
	54	}
	55	}
	56
	57	int
	58	main (int argc, char **argv)
	59	{
	60	const char *name;
	61	char **prog_argv = NULL;
	62	char **prog_envp = NULL;
	63	struct bfd *prog_bfd;
	64	enum sim_stop reason;
	65	int sigrc = 0;
	66	int single_step = 0;
	67	void (*prev_sigint) (int);
	68
	69	myname = lbasename (argv[0]);
	70
	71	/* INTERNAL: When MYNAME is `step', single step the simulator
	72	instead of allowing it to run free. The sole purpose of this
	73	HACK is to allow the sim_resume interface's step argument to be
	74	tested without having to build/run gdb. */
	75	if (strlen (myname) > 4 && strcmp (myname - 4, "step") == 0)
	76	{
	77	single_step = 1;
	78	}
	79
	80	/* Create an instance of the simulator. */
	81	default_callback.init (&default_callback);
	82	sd = sim_open (SIM_OPEN_STANDALONE, &default_callback, NULL, argv);
	83	if (sd == 0)
	84	exit (1);
	85	if (STATE_MAGIC (sd) != SIM_MAGIC_NUMBER)
	86	{
	87	fprintf (stderr, "Internal error - bad magic number in simulator struct\n");
	88	abort ();
	89	}
	90
	91	/* We can't set the endianness in the callback structure until sim_config is
	92	called, which happens in sim_open. If it's still the default, switch it.
	93	Don't use CURRENT_TARGET_BYTE_ORDER as all its internal processing already
	94	happened in sim_config. */
	95	if (default_callback.target_endian == BFD_ENDIAN_UNKNOWN)
	96	default_callback.target_endian = current_target_byte_order;
	97
	98	/* Was there a program to run? */
	99	prog_argv = STATE_PROG_ARGV (sd);
	100	prog_envp = STATE_PROG_ENVP (sd) ? : environ;
	101	prog_bfd = STATE_PROG_BFD (sd);
	102	if (prog_argv == NULL \|\| *prog_argv == NULL)
	103	usage ();
	104
	105	name = STATE_PROG_FILE (sd);
	106
	107	/* For simulators that don't open prog during sim_open() */
	108	if (prog_bfd == NULL)
	109	{
	110	prog_bfd = bfd_openr (name, 0);
	111	if (prog_bfd == NULL)
	112	{
	113	fprintf (stderr, "%s: can't open \"%s\": %s\n",
	114	myname, name, bfd_errmsg (bfd_get_error ()));
	115	exit (1);
	116	}
	117	if (!bfd_check_format (prog_bfd, bfd_object))
	118	{
	119	fprintf (stderr, "%s: \"%s\" is not an object file: %s\n",
	120	myname, name, bfd_errmsg (bfd_get_error ()));
	121	exit (1);
	122	}
	123	}
	124
	125	if (STATE_VERBOSE_P (sd))
	126	printf ("%s %s\n", myname, name);
	127
	128	/* Load the program into the simulator. */
	129	if (sim_load (sd, name, prog_bfd, 0) == SIM_RC_FAIL)
	130	exit (1);
	131
	132	/* Prepare the program for execution. */
	133	sim_create_inferior (sd, prog_bfd, prog_argv, prog_envp);
	134
	135	/* To accommodate relative file paths, chdir to sysroot now. We
	136	mustn't do this until BFD has opened the program, else we wouldn't
	137	find the executable if it has a relative file path. */
	138	if (simulator_sysroot[0] != '\0' && chdir (simulator_sysroot) < 0)
	139	{
	140	fprintf (stderr, "%s: can't change directory to \"%s\"\n",
	141	myname, simulator_sysroot);
	142	exit (1);
	143	}
	144
	145	/* Run/Step the program. */
	146	if (single_step)
	147	{
	148	do
	149	{
	150	prev_sigint = signal (SIGINT, cntrl_c);
	151	sim_resume (sd, 1/step/, 0);
	152	signal (SIGINT, prev_sigint);
	153	sim_stop_reason (sd, &reason, &sigrc);
	154
	155	if ((reason == sim_stopped) &&
	156	(sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
	157	break; /* exit on control-C */
	158	}
	159	/* remain on breakpoint or signals in oe mode*/
	160	while (((reason == sim_signalled) &&
	161	(sigrc == sim_signal_to_host (sd, SIM_SIGTRAP))) \|\|
	162	((reason == sim_stopped) &&
	163	(STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)));
	164	}
	165	else
	166	{
	167	do
	168	{
	169	#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
	170	struct sigaction sa, osa;
	171	sa.sa_handler = cntrl_c;
	172	sigemptyset (&sa.sa_mask);
	173	sa.sa_flags = 0;
	174	sigaction (SIGINT, &sa, &osa);
	175	prev_sigint = osa.sa_handler;
	176	#else
	177	prev_sigint = signal (SIGINT, cntrl_c);
	178	#endif
	179	sim_resume (sd, 0, sigrc);
	180	signal (SIGINT, prev_sigint);
	181	sim_stop_reason (sd, &reason, &sigrc);
	182
	183	if ((reason == sim_stopped) &&
	184	(sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
	185	break; /* exit on control-C */
	186
	187	/* remain on signals in oe mode */
	188	} while ((reason == sim_stopped) &&
	189	(STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT));
	190
	191	}
	192	/* Print any stats the simulator collected. */
	193	if (STATE_VERBOSE_P (sd))
	194	sim_info (sd, 0);
	195
	196	/* Shutdown the simulator. */
	197	sim_close (sd, 0);
	198
	199	/* If reason is sim_exited, then sigrc holds the exit code which we want
	200	to return. If reason is sim_stopped or sim_signalled, then sigrc holds
	201	the signal that the simulator received; we want to return that to
	202	indicate failure. */
	203
	204	/* Why did we stop? */
	205	switch (reason)
	206	{
	207	case sim_signalled:
	208	case sim_stopped:
	209	if (sigrc != 0)
	210	fprintf (stderr, "program stopped with signal %d (%s).\n", sigrc,
	211	strsignal (sigrc));
	212	break;
	213
	214	case sim_exited:
	215	break;
	216
	217	default:
	218	fprintf (stderr, "program in undefined state (%d:%d)\n", reason, sigrc);
	219	break;
	220
	221	}
	222
	223	return sigrc;
	224	}
	225
	226	static void
	227	usage (void)
	228	{
	229	fprintf (stderr, "Usage: %s [options] [VAR=VAL\|--] program [program args]\n",
	230	myname);
	231	fprintf (stderr, "Run `%s --help' for full list of options.\n", myname);
	232	exit (1);
	233	}