[deliverable/binutils-gdb.git] / sim / common / sim-config.c

/* The common simulator framework for GDB, the GNU Debugger.

   Copyright 2002-2016 Free Software Foundation, Inc.

   Contributed by Andrew Cagney and Red Hat.

   This file is part of GDB.

   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"
#include "bfd.h"


enum bfd_endian current_target_byte_order = BFD_ENDIAN_UNKNOWN;
int current_stdio;

enum sim_alignments current_alignment;

#if defined (WITH_FLOATING_POINT)
int current_floating_point;
#endif


/* map a byte order onto a textual string */

static const char *
config_byte_order_to_a (enum bfd_endian byte_order)
{
  switch (byte_order)
    {
    case BFD_ENDIAN_LITTLE:
      return "LITTLE_ENDIAN";
    case BFD_ENDIAN_BIG:
      return "BIG_ENDIAN";
    case BFD_ENDIAN_UNKNOWN:
      return "UNKNOWN_ENDIAN";
    }
  return "UNKNOWN";
}


static const char *
config_stdio_to_a (int stdio)
{
  switch (stdio)
    {
    case DONT_USE_STDIO:
      return "DONT_USE_STDIO";
    case DO_USE_STDIO:
      return "DO_USE_STDIO";
    case 0:
      return "0";
    }
  return "UNKNOWN";
}


static const char *
config_environment_to_a (enum sim_environment environment)
{
  switch (environment)
    {
    case ALL_ENVIRONMENT:
      return "ALL_ENVIRONMENT";
    case USER_ENVIRONMENT:
      return "USER_ENVIRONMENT";
    case VIRTUAL_ENVIRONMENT:
      return "VIRTUAL_ENVIRONMENT";
    case OPERATING_ENVIRONMENT:
      return "OPERATING_ENVIRONMENT";
    }
  return "UNKNOWN";
}


static const char *
config_alignment_to_a (enum sim_alignments alignment)
{
  switch (alignment)
    {
    case MIXED_ALIGNMENT:
      return "MIXED_ALIGNMENT";
    case NONSTRICT_ALIGNMENT:
      return "NONSTRICT_ALIGNMENT";
    case STRICT_ALIGNMENT:
      return "STRICT_ALIGNMENT";
    case FORCED_ALIGNMENT:
      return "FORCED_ALIGNMENT";
    }
  return "UNKNOWN";
}


#if defined (WITH_FLOATING_POINT)
static const char *
config_floating_point_to_a (int floating_point)
{
  switch (floating_point)
    {
    case SOFT_FLOATING_POINT:
      return "SOFT_FLOATING_POINT";
    case HARD_FLOATING_POINT:
      return "HARD_FLOATING_POINT";
    case 0:
      return "0";
    }
  return "UNKNOWN";
}
#endif

/* Set the default environment, prior to parsing argv.  */

void
sim_config_default (SIM_DESC sd)
{
   /* Set the current environment to ALL_ENVIRONMENT to indicate none has been
      selected yet.  This is so that after parsing argv, we know whether the
      environment was explicitly specified or not.  */
  STATE_ENVIRONMENT (sd) = ALL_ENVIRONMENT;
}

/* Complete and verify the simulation environment.  */

SIM_RC
sim_config (SIM_DESC sd)
{
  enum bfd_endian prefered_target_byte_order;
  SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);

  /* extract all relevant information */
  if (STATE_PROG_BFD (sd) == NULL
      /* If we have a binary input file (presumably with specified
	 "--architecture"), it'll have no endianness.  */
      || (!bfd_little_endian (STATE_PROG_BFD (sd))
	  && !bfd_big_endian (STATE_PROG_BFD (sd))))
    prefered_target_byte_order = BFD_ENDIAN_UNKNOWN;
  else
    prefered_target_byte_order = (bfd_little_endian (STATE_PROG_BFD (sd))
				  ? BFD_ENDIAN_LITTLE
				  : BFD_ENDIAN_BIG);

  /* set the target byte order */
#if (WITH_TREE_PROPERTIES)
  if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
    current_target_byte_order
      = (tree_find_boolean_property (root, "/options/little-endian?")
	 ? BFD_ENDIAN_LITTLE
	 : BFD_ENDIAN_BIG);
#endif
  if (current_target_byte_order == BFD_ENDIAN_UNKNOWN
      && prefered_target_byte_order != BFD_ENDIAN_UNKNOWN)
    current_target_byte_order = prefered_target_byte_order;
  if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
    current_target_byte_order = WITH_TARGET_BYTE_ORDER;
  if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
    current_target_byte_order = WITH_DEFAULT_TARGET_BYTE_ORDER;

  /* verify the target byte order */
  if (CURRENT_TARGET_BYTE_ORDER == BFD_ENDIAN_UNKNOWN)
    {
      sim_io_eprintf (sd, "Target byte order unspecified\n");
      return SIM_RC_FAIL;
    }
  if (CURRENT_TARGET_BYTE_ORDER != current_target_byte_order)
    sim_io_eprintf (sd, "Target (%s) and configured (%s) byte order in conflict\n",
		  config_byte_order_to_a (current_target_byte_order),
		  config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER));
  if (prefered_target_byte_order != BFD_ENDIAN_UNKNOWN
      && CURRENT_TARGET_BYTE_ORDER != prefered_target_byte_order)
    sim_io_eprintf (sd, "Target (%s) and specified (%s) byte order in conflict\n",
		  config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER),
		  config_byte_order_to_a (prefered_target_byte_order));


  /* set the stdio */
  if (current_stdio == 0)
    current_stdio = WITH_STDIO;
  if (current_stdio == 0)
    current_stdio = DO_USE_STDIO;

  /* verify the stdio */
  if (CURRENT_STDIO == 0)
    {
      sim_io_eprintf (sd, "Target standard IO unspecified\n");
      return SIM_RC_FAIL;
    }
  if (CURRENT_STDIO != current_stdio)
    {
      sim_io_eprintf (sd, "Target (%s) and configured (%s) standard IO in conflict\n",
		      config_stdio_to_a (CURRENT_STDIO),
		      config_stdio_to_a (current_stdio));
      return SIM_RC_FAIL;
    }


  /* check the value of MSB */
  if (WITH_TARGET_WORD_MSB != 0
      && WITH_TARGET_WORD_MSB != (WITH_TARGET_WORD_BITSIZE - 1))
    {
      sim_io_eprintf (sd, "Target bitsize (%d) contradicts target most significant bit (%d)\n",
		      WITH_TARGET_WORD_BITSIZE, WITH_TARGET_WORD_MSB);
      return SIM_RC_FAIL;
    }


  /* set the environment */
#if (WITH_TREE_PROPERTIES)
  if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
    {
      const char *env =
	tree_find_string_property (root, "/openprom/options/env");
      STATE_ENVIRONMENT (sd) = ((strcmp (env, "user") == 0
				 || strcmp (env, "uea") == 0)
				? USER_ENVIRONMENT
				: (strcmp (env, "virtual") == 0
				   || strcmp (env, "vea") == 0)
				? VIRTUAL_ENVIRONMENT
				: (strcmp (env, "operating") == 0
				   || strcmp (env, "oea") == 0)
				? OPERATING_ENVIRONMENT
				: ALL_ENVIRONMENT);
    }
#endif
  if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
    STATE_ENVIRONMENT (sd) = DEFAULT_ENVIRONMENT;


  /* set the alignment */
#if (WITH_TREE_PROPERTIES)
  if (current_alignment == 0)
    current_alignment =
      (tree_find_boolean_property (root, "/openprom/options/strict-alignment?")
       ? STRICT_ALIGNMENT
       : NONSTRICT_ALIGNMENT);
#endif
  if (current_alignment == 0)
    current_alignment = WITH_ALIGNMENT;
  if (current_alignment == 0)
    current_alignment = WITH_DEFAULT_ALIGNMENT;

  /* verify the alignment */
  if (CURRENT_ALIGNMENT == 0)
    {
      sim_io_eprintf (sd, "Target alignment unspecified\n");
      return SIM_RC_FAIL;
    }
  if (CURRENT_ALIGNMENT != current_alignment)
    {
      sim_io_eprintf (sd, "Target (%s) and configured (%s) alignment in conflict\n",
		      config_alignment_to_a (CURRENT_ALIGNMENT),
		      config_alignment_to_a (current_alignment));
      return SIM_RC_FAIL;
    }

#if defined (WITH_FLOATING_POINT)

  /* set the floating point */
  if (current_floating_point == 0)
    current_floating_point = WITH_FLOATING_POINT;

  /* verify the floating point */
  if (CURRENT_FLOATING_POINT == 0)
    {
      sim_io_eprintf (sd, "Target floating-point unspecified\n");
      return SIM_RC_FAIL;
    }
  if (CURRENT_FLOATING_POINT != current_floating_point)
    {
      sim_io_eprintf (sd, "Target (%s) and configured (%s) floating-point in conflict\n",
		      config_alignment_to_a (CURRENT_FLOATING_POINT),
		      config_alignment_to_a (current_floating_point));
      return SIM_RC_FAIL;
    }

#endif
  return SIM_RC_OK;
}


void
print_sim_config (SIM_DESC sd)
{
#if defined (__GNUC__) && defined (__VERSION__)
  sim_io_printf (sd, "Compiled by GCC %s on %s %s\n",
			  __VERSION__, __DATE__, __TIME__);
#else
  sim_io_printf (sd, "Compiled on %s %s\n", __DATE__, __TIME__);
#endif

  sim_io_printf (sd, "WITH_TARGET_BYTE_ORDER   = %s\n",
		 config_byte_order_to_a (WITH_TARGET_BYTE_ORDER));

  sim_io_printf (sd, "WITH_DEFAULT_TARGET_BYTE_ORDER   = %s\n",
		 config_byte_order_to_a (WITH_DEFAULT_TARGET_BYTE_ORDER));

  sim_io_printf (sd, "HOST_BYTE_ORDER          = %s\n",
		 config_byte_order_to_a (HOST_BYTE_ORDER));

  sim_io_printf (sd, "WITH_STDIO               = %s\n",
		 config_stdio_to_a (WITH_STDIO));

  sim_io_printf (sd, "WITH_TARGET_WORD_MSB     = %d\n",
		 WITH_TARGET_WORD_MSB);

  sim_io_printf (sd, "WITH_TARGET_WORD_BITSIZE = %d\n",
		 WITH_TARGET_WORD_BITSIZE);

  sim_io_printf (sd, "WITH_TARGET_ADDRESS_BITSIZE = %d\n",
		 WITH_TARGET_ADDRESS_BITSIZE);

  sim_io_printf (sd, "WITH_TARGET_CELL_BITSIZE = %d\n",
		 WITH_TARGET_CELL_BITSIZE);

  sim_io_printf (sd, "WITH_TARGET_FLOATING_POINT_BITSIZE = %d\n",
		 WITH_TARGET_FLOATING_POINT_BITSIZE);

  sim_io_printf (sd, "WITH_ENVIRONMENT = %s\n",
		 config_environment_to_a (WITH_ENVIRONMENT));

  sim_io_printf (sd, "WITH_ALIGNMENT = %s\n",
		 config_alignment_to_a (WITH_ALIGNMENT));

#if defined (WITH_DEFAULT_ALIGNMENT)
  sim_io_printf (sd, "WITH_DEFAULT_ALIGNMENT = %s\n",
		 config_alignment_to_a (WITH_DEFAULT_ALIGNMENT));
#endif

#if defined (WITH_XOR_ENDIAN)
  sim_io_printf (sd, "WITH_XOR_ENDIAN = %d\n", WITH_XOR_ENDIAN);
#endif

#if defined (WITH_FLOATING_POINT)
  sim_io_printf (sd, "WITH_FLOATING_POINT = %s\n",
		 config_floating_point_to_a (WITH_FLOATING_POINT));
#endif

#if defined (WITH_SMP)
  sim_io_printf (sd, "WITH_SMP = %d\n", WITH_SMP);
#endif

#if defined (WITH_RESERVED_BITS)
  sim_io_printf (sd, "WITH_RESERVED_BITS = %d\n", WITH_RESERVED_BITS);
#endif

#if defined (WITH_PROFILE)
  sim_io_printf (sd, "WITH_PROFILE = %d\n", WITH_PROFILE);
#endif

}
Commit	Line	Data
b85e4829 AC	1	/* The common simulator framework for GDB, the GNU Debugger.
b85e4829 AC	2
618f726f	3	Copyright 2002-2016 Free Software Foundation, Inc.
b85e4829 AC	4
	5	Contributed by Andrew Cagney and Red Hat.
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
4744ac1b	11	the Free Software Foundation; either version 3 of the License, or
b85e4829 AC	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
4744ac1b	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	21
	22
	23	#include "sim-main.h"
	24	#include "sim-assert.h"
	25	#include "bfd.h"
	26
	27
1ac72f06	28	enum bfd_endian current_target_byte_order = BFD_ENDIAN_UNKNOWN;
c906108c SS	29	int current_stdio;
	30
	31	enum sim_alignments current_alignment;
	32
	33	#if defined (WITH_FLOATING_POINT)
	34	int current_floating_point;
	35	#endif
	36
	37
	38
	39	/* map a byte order onto a textual string */
	40
	41	static const char *
1ac72f06	42	config_byte_order_to_a (enum bfd_endian byte_order)
c906108c SS	43	{
	44	switch (byte_order)
	45	{
1ac72f06	46	case BFD_ENDIAN_LITTLE:
c906108c	47	return "LITTLE_ENDIAN";
1ac72f06	48	case BFD_ENDIAN_BIG:
c906108c	49	return "BIG_ENDIAN";
1ac72f06 MF	50	case BFD_ENDIAN_UNKNOWN:
1ac72f06 MF	51	return "UNKNOWN_ENDIAN";
c906108c SS	52	}
	53	return "UNKNOWN";
	54	}
	55
	56
	57	static const char *
	58	config_stdio_to_a (int stdio)
	59	{
	60	switch (stdio)
	61	{
	62	case DONT_USE_STDIO:
	63	return "DONT_USE_STDIO";
	64	case DO_USE_STDIO:
	65	return "DO_USE_STDIO";
	66	case 0:
	67	return "0";
	68	}
	69	return "UNKNOWN";
	70	}
	71
	72
	73	static const char *
	74	config_environment_to_a (enum sim_environment environment)
	75	{
	76	switch (environment)
	77	{
	78	case ALL_ENVIRONMENT:
	79	return "ALL_ENVIRONMENT";
	80	case USER_ENVIRONMENT:
	81	return "USER_ENVIRONMENT";
	82	case VIRTUAL_ENVIRONMENT:
	83	return "VIRTUAL_ENVIRONMENT";
	84	case OPERATING_ENVIRONMENT:
	85	return "OPERATING_ENVIRONMENT";
	86	}
	87	return "UNKNOWN";
	88	}
	89
	90
	91	static const char *
	92	config_alignment_to_a (enum sim_alignments alignment)
	93	{
	94	switch (alignment)
	95	{
	96	case MIXED_ALIGNMENT:
	97	return "MIXED_ALIGNMENT";
	98	case NONSTRICT_ALIGNMENT:
	99	return "NONSTRICT_ALIGNMENT";
	100	case STRICT_ALIGNMENT:
	101	return "STRICT_ALIGNMENT";
	102	case FORCED_ALIGNMENT:
	103	return "FORCED_ALIGNMENT";
	104	}
	105	return "UNKNOWN";
	106	}
	107
	108
	109	#if defined (WITH_FLOATING_POINT)
	110	static const char *
	111	config_floating_point_to_a (int floating_point)
	112	{
	113	switch (floating_point)
	114	{
	115	case SOFT_FLOATING_POINT:
116	return "SOFT_FLOATING_POINT";
117	case HARD_FLOATING_POINT:
118	return "HARD_FLOATING_POINT";
119	case 0:
120	return "0";
121	}
122	return "UNKNOWN";
123	}
124	#endif
125
126	/* Set the default environment, prior to parsing argv. */
127
128	void
129	sim_config_default (SIM_DESC sd)
130	{
131	/* Set the current environment to ALL_ENVIRONMENT to indicate none has been
132	selected yet. This is so that after parsing argv, we know whether the
133	environment was explicitly specified or not. */
134	STATE_ENVIRONMENT (sd) = ALL_ENVIRONMENT;
135	}
136
137	/* Complete and verify the simulation environment. */
138
139	SIM_RC
140	sim_config (SIM_DESC sd)
141	{
1ac72f06	142	enum bfd_endian prefered_target_byte_order;
c906108c SS	143	SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER);
	144
	145	/* extract all relevant information */
1d72487d HPN	146	if (STATE_PROG_BFD (sd) == NULL
	147	/* If we have a binary input file (presumably with specified
	148	"--architecture"), it'll have no endianness. */
	149	\|\| (!bfd_little_endian (STATE_PROG_BFD (sd))
	150	&& !bfd_big_endian (STATE_PROG_BFD (sd))))
1ac72f06	151	prefered_target_byte_order = BFD_ENDIAN_UNKNOWN;
c906108c	152	else
34b47c38	153	prefered_target_byte_order = (bfd_little_endian (STATE_PROG_BFD (sd))
1ac72f06 MF	154	? BFD_ENDIAN_LITTLE
1ac72f06 MF	155	: BFD_ENDIAN_BIG);
c906108c	156
c906108c SS	157	/* set the target byte order */
c906108c SS	158	#if (WITH_TREE_PROPERTIES)
1ac72f06	159	if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
c906108c SS	160	current_target_byte_order
c906108c SS	161	= (tree_find_boolean_property (root, "/options/little-endian?")
1ac72f06 MF	162	? BFD_ENDIAN_LITTLE
1ac72f06 MF	163	: BFD_ENDIAN_BIG);
c906108c	164	#endif
1ac72f06 MF	165	if (current_target_byte_order == BFD_ENDIAN_UNKNOWN
1ac72f06 MF	166	&& prefered_target_byte_order != BFD_ENDIAN_UNKNOWN)
c906108c	167	current_target_byte_order = prefered_target_byte_order;
1ac72f06	168	if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
c906108c	169	current_target_byte_order = WITH_TARGET_BYTE_ORDER;
1ac72f06	170	if (current_target_byte_order == BFD_ENDIAN_UNKNOWN)
c906108c SS	171	current_target_byte_order = WITH_DEFAULT_TARGET_BYTE_ORDER;
	172
	173	/* verify the target byte order */
1ac72f06	174	if (CURRENT_TARGET_BYTE_ORDER == BFD_ENDIAN_UNKNOWN)
c906108c SS	175	{
	176	sim_io_eprintf (sd, "Target byte order unspecified\n");
	177	return SIM_RC_FAIL;
	178	}
	179	if (CURRENT_TARGET_BYTE_ORDER != current_target_byte_order)
	180	sim_io_eprintf (sd, "Target (%s) and configured (%s) byte order in conflict\n",
	181	config_byte_order_to_a (current_target_byte_order),
	182	config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER));
1ac72f06	183	if (prefered_target_byte_order != BFD_ENDIAN_UNKNOWN
c906108c SS	184	&& CURRENT_TARGET_BYTE_ORDER != prefered_target_byte_order)
	185	sim_io_eprintf (sd, "Target (%s) and specified (%s) byte order in conflict\n",
	186	config_byte_order_to_a (CURRENT_TARGET_BYTE_ORDER),
	187	config_byte_order_to_a (prefered_target_byte_order));
	188
	189
	190	/* set the stdio */
	191	if (current_stdio == 0)
	192	current_stdio = WITH_STDIO;
	193	if (current_stdio == 0)
	194	current_stdio = DO_USE_STDIO;
	195
	196	/* verify the stdio */
	197	if (CURRENT_STDIO == 0)
	198	{
	199	sim_io_eprintf (sd, "Target standard IO unspecified\n");
	200	return SIM_RC_FAIL;
	201	}
	202	if (CURRENT_STDIO != current_stdio)
	203	{
	204	sim_io_eprintf (sd, "Target (%s) and configured (%s) standard IO in conflict\n",
	205	config_stdio_to_a (CURRENT_STDIO),
	206	config_stdio_to_a (current_stdio));
	207	return SIM_RC_FAIL;
	208	}
028f6515 MF	209
028f6515 MF	210
c906108c SS	211	/* check the value of MSB */
	212	if (WITH_TARGET_WORD_MSB != 0
	213	&& WITH_TARGET_WORD_MSB != (WITH_TARGET_WORD_BITSIZE - 1))
	214	{
	215	sim_io_eprintf (sd, "Target bitsize (%d) contradicts target most significant bit (%d)\n",
	216	WITH_TARGET_WORD_BITSIZE, WITH_TARGET_WORD_MSB);
	217	return SIM_RC_FAIL;
	218	}
028f6515 MF	219
028f6515 MF	220
c906108c SS	221	/* set the environment */
	222	#if (WITH_TREE_PROPERTIES)
	223	if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
	224	{
	225	const char *env =
34b47c38 MF	226	tree_find_string_property (root, "/openprom/options/env");
	227	STATE_ENVIRONMENT (sd) = ((strcmp (env, "user") == 0
	228	\|\| strcmp (env, "uea") == 0)
c906108c	229	? USER_ENVIRONMENT
34b47c38 MF	230	: (strcmp (env, "virtual") == 0
34b47c38 MF	231	\|\| strcmp (env, "vea") == 0)
c906108c	232	? VIRTUAL_ENVIRONMENT
34b47c38 MF	233	: (strcmp (env, "operating") == 0
34b47c38 MF	234	\|\| strcmp (env, "oea") == 0)
c906108c SS	235	? OPERATING_ENVIRONMENT
	236	: ALL_ENVIRONMENT);
	237	}
	238	#endif
	239	if (STATE_ENVIRONMENT (sd) == ALL_ENVIRONMENT)
	240	STATE_ENVIRONMENT (sd) = DEFAULT_ENVIRONMENT;
028f6515 MF	241
028f6515 MF	242
c906108c SS	243	/* set the alignment */
	244	#if (WITH_TREE_PROPERTIES)
	245	if (current_alignment == 0)
	246	current_alignment =
34b47c38	247	(tree_find_boolean_property (root, "/openprom/options/strict-alignment?")
c906108c SS	248	? STRICT_ALIGNMENT
	249	: NONSTRICT_ALIGNMENT);
	250	#endif
	251	if (current_alignment == 0)
	252	current_alignment = WITH_ALIGNMENT;
	253	if (current_alignment == 0)
	254	current_alignment = WITH_DEFAULT_ALIGNMENT;
028f6515	255
c906108c SS	256	/* verify the alignment */
	257	if (CURRENT_ALIGNMENT == 0)
	258	{
	259	sim_io_eprintf (sd, "Target alignment unspecified\n");
	260	return SIM_RC_FAIL;
	261	}
	262	if (CURRENT_ALIGNMENT != current_alignment)
	263	{
	264	sim_io_eprintf (sd, "Target (%s) and configured (%s) alignment in conflict\n",
	265	config_alignment_to_a (CURRENT_ALIGNMENT),
	266	config_alignment_to_a (current_alignment));
	267	return SIM_RC_FAIL;
	268	}
028f6515	269
c906108c	270	#if defined (WITH_FLOATING_POINT)
028f6515	271
c906108c SS	272	/* set the floating point */
	273	if (current_floating_point == 0)
	274	current_floating_point = WITH_FLOATING_POINT;
028f6515	275
c906108c SS	276	/* verify the floating point */
	277	if (CURRENT_FLOATING_POINT == 0)
	278	{
	279	sim_io_eprintf (sd, "Target floating-point unspecified\n");
	280	return SIM_RC_FAIL;
	281	}
	282	if (CURRENT_FLOATING_POINT != current_floating_point)
	283	{
	284	sim_io_eprintf (sd, "Target (%s) and configured (%s) floating-point in conflict\n",
	285	config_alignment_to_a (CURRENT_FLOATING_POINT),
	286	config_alignment_to_a (current_floating_point));
	287	return SIM_RC_FAIL;
	288	}
028f6515	289
c906108c SS	290	#endif
	291	return SIM_RC_OK;
	292	}
	293
	294
	295	void
	296	print_sim_config (SIM_DESC sd)
	297	{
	298	#if defined (__GNUC__) && defined (__VERSION__)
	299	sim_io_printf (sd, "Compiled by GCC %s on %s %s\n",
	300	__VERSION__, __DATE__, __TIME__);
	301	#else
	302	sim_io_printf (sd, "Compiled on %s %s\n", __DATE__, __TIME__);
	303	#endif
	304
	305	sim_io_printf (sd, "WITH_TARGET_BYTE_ORDER = %s\n",
	306	config_byte_order_to_a (WITH_TARGET_BYTE_ORDER));
	307
	308	sim_io_printf (sd, "WITH_DEFAULT_TARGET_BYTE_ORDER = %s\n",
	309	config_byte_order_to_a (WITH_DEFAULT_TARGET_BYTE_ORDER));
	310
0cb8d851 MF	311	sim_io_printf (sd, "HOST_BYTE_ORDER = %s\n",
0cb8d851 MF	312	config_byte_order_to_a (HOST_BYTE_ORDER));
c906108c SS	313
	314	sim_io_printf (sd, "WITH_STDIO = %s\n",
	315	config_stdio_to_a (WITH_STDIO));
	316
	317	sim_io_printf (sd, "WITH_TARGET_WORD_MSB = %d\n",
	318	WITH_TARGET_WORD_MSB);
	319
	320	sim_io_printf (sd, "WITH_TARGET_WORD_BITSIZE = %d\n",
	321	WITH_TARGET_WORD_BITSIZE);
	322
	323	sim_io_printf (sd, "WITH_TARGET_ADDRESS_BITSIZE = %d\n",
	324	WITH_TARGET_ADDRESS_BITSIZE);
	325
	326	sim_io_printf (sd, "WITH_TARGET_CELL_BITSIZE = %d\n",
	327	WITH_TARGET_CELL_BITSIZE);
	328
	329	sim_io_printf (sd, "WITH_TARGET_FLOATING_POINT_BITSIZE = %d\n",
	330	WITH_TARGET_FLOATING_POINT_BITSIZE);
	331
	332	sim_io_printf (sd, "WITH_ENVIRONMENT = %s\n",
	333	config_environment_to_a (WITH_ENVIRONMENT));
	334
	335	sim_io_printf (sd, "WITH_ALIGNMENT = %s\n",
	336	config_alignment_to_a (WITH_ALIGNMENT));
	337
	338	#if defined (WITH_DEFAULT_ALIGNMENT)
	339	sim_io_printf (sd, "WITH_DEFAULT_ALIGNMENT = %s\n",
	340	config_alignment_to_a (WITH_DEFAULT_ALIGNMENT));
	341	#endif
	342
	343	#if defined (WITH_XOR_ENDIAN)
	344	sim_io_printf (sd, "WITH_XOR_ENDIAN = %d\n", WITH_XOR_ENDIAN);
	345	#endif
	346
	347	#if defined (WITH_FLOATING_POINT)
	348	sim_io_printf (sd, "WITH_FLOATING_POINT = %s\n",
	349	config_floating_point_to_a (WITH_FLOATING_POINT));
	350	#endif
	351
	352	#if defined (WITH_SMP)
	353	sim_io_printf (sd, "WITH_SMP = %d\n", WITH_SMP);
	354	#endif
	355
	356	#if defined (WITH_RESERVED_BITS)
	357	sim_io_printf (sd, "WITH_RESERVED_BITS = %d\n", WITH_RESERVED_BITS);
	358	#endif
028f6515	359
c906108c SS	360	#if defined (WITH_PROFILE)
	361	sim_io_printf (sd, "WITH_PROFILE = %d\n", WITH_PROFILE);
	362	#endif
028f6515	363
c906108c	364	}