[deliverable/binutils-gdb.git] / gdb / gdbarch.c

/* Semi-dynamic architecture support for GDB, the GNU debugger.
   Copyright 1998-1999, Free Software Foundation, Inc.

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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "defs.h"

/* Just include everything in sight so that the every old definition
   of macro is visible. */
#include "gdb_string.h"
#include <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "inferior.h"
#include "breakpoint.h"
#include "wait.h"
#include "gdbcore.h"
#include "gdbcmd.h"
#include "target.h"
#include "gdbthread.h"
#include "annotate.h"
#include "symfile.h"		/* for overlay functions */
#include "symcat.h"


/* Non-zero if we want to trace architecture code.  */

#ifndef GDBARCH_DEBUG
#define GDBARCH_DEBUG 0
#endif
int gdbarch_debug = GDBARCH_DEBUG;


/* Functions to manipulate the endianness of the target.  */

#ifdef TARGET_BYTE_ORDER_SELECTABLE
/* compat - Catch old targets that expect a selectable byte-order to
   default to BIG_ENDIAN */
#ifndef TARGET_BYTE_ORDER_DEFAULT
#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
#endif
#endif
#if !TARGET_BYTE_ORDER_SELECTABLE_P
#ifndef TARGET_BYTE_ORDER_DEFAULT
/* compat - Catch old non byte-order selectable targets that do not
   define TARGET_BYTE_ORDER_DEFAULT and instead expect
   TARGET_BYTE_ORDER to be used as the default.  For targets that
   defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
   below will get a strange compiler warning. */
#define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
#endif
#endif
#ifndef TARGET_BYTE_ORDER_DEFAULT
#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
#endif
int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
int target_byte_order_auto = 1;

/* Chain containing the \"set endian\" commands.  */
static struct cmd_list_element *endianlist = NULL;

/* Called by ``show endian''.  */
static void show_endian PARAMS ((char *, int));
static void
show_endian (args, from_tty)
     char *args;
     int from_tty;
{
  char *msg =
    (TARGET_BYTE_ORDER_AUTO
     ? "The target endianness is set automatically (currently %s endian)\n"
     : "The target is assumed to be %s endian\n");
  printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
}

/* Called if the user enters ``set endian'' without an argument.  */
static void set_endian PARAMS ((char *, int));
static void
set_endian (args, from_tty)
     char *args;
     int from_tty;
{
  printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
  show_endian (args, from_tty);
}

/* Called by ``set endian big''.  */
static void set_endian_big PARAMS ((char *, int));
static void
set_endian_big (args, from_tty)
     char *args;
     int from_tty;
{
  if (TARGET_BYTE_ORDER_SELECTABLE_P)
    {
      target_byte_order = BIG_ENDIAN;
      target_byte_order_auto = 0;
    }
  else
    {
      printf_unfiltered ("Byte order is not selectable.");
      show_endian (args, from_tty);
    }
}

/* Called by ``set endian little''.  */
static void set_endian_little PARAMS ((char *, int));
static void
set_endian_little (args, from_tty)
     char *args;
     int from_tty;
{
  if (TARGET_BYTE_ORDER_SELECTABLE_P)
    {
      target_byte_order = LITTLE_ENDIAN;
      target_byte_order_auto = 0;
    }
  else
    {
      printf_unfiltered ("Byte order is not selectable.");
      show_endian (args, from_tty);
    }
}

/* Called by ``set endian auto''.  */
static void set_endian_auto PARAMS ((char *, int));
static void
set_endian_auto (args, from_tty)
     char *args;
     int from_tty;
{
  if (TARGET_BYTE_ORDER_SELECTABLE_P)
    {
      target_byte_order_auto = 1;
    }
  else
    {
      printf_unfiltered ("Byte order is not selectable.");
      show_endian (args, from_tty);
    }
}

/* Set the endianness from a BFD.  */
static void set_endian_from_file PARAMS ((bfd *));
static void
set_endian_from_file (abfd)
     bfd *abfd;
{
  if (TARGET_BYTE_ORDER_SELECTABLE_P)
    {
      int want;
      
      if (bfd_big_endian (abfd))
	want = BIG_ENDIAN;
      else
	want = LITTLE_ENDIAN;
      if (TARGET_BYTE_ORDER_AUTO)
	target_byte_order = want;
      else if (TARGET_BYTE_ORDER != want)
	warning ("%s endian file does not match %s endian target.",
		 want == BIG_ENDIAN ? "big" : "little",
		 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
    }
  else
    {
      if (bfd_big_endian (abfd)
	  ? TARGET_BYTE_ORDER != BIG_ENDIAN
	  : TARGET_BYTE_ORDER == BIG_ENDIAN)
	warning ("%s endian file does not match %s endian target.",
		 bfd_big_endian (abfd) ? "big" : "little",
		 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
    }
}


/* Functions to manipulate the architecture of the target */

int target_architecture_auto = 1;
extern const struct bfd_arch_info bfd_default_arch_struct;
const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *ap));

/* Do the real work of changing the current architecture */

static int arch_valid PARAMS ((const struct bfd_arch_info *arch));
static int
arch_ok (arch)
     const struct bfd_arch_info *arch;
{
  /* Should be performing the more basic check that the binary is
     compatible with GDB. */
  /* Check with the target that the architecture is valid. */
  return (target_architecture_hook == NULL
	  || target_architecture_hook (arch));
}

enum set_arch { set_arch_auto, set_arch_manual };

static void
set_arch (arch, type)
     const struct bfd_arch_info *arch;
     enum set_arch type;
{
  switch (type)
    {
    case set_arch_auto:
      if (!arch_ok (arch))
	warning ("Target may not support %s architecture",
		 arch->printable_name);
      target_architecture = arch;
      break;
    case set_arch_manual:
      if (!arch_ok (arch))
	{
	  printf_unfiltered ("Target does not support `%s' architecture.\n",
			     arch->printable_name);
	}
      else
	{
	  target_architecture_auto = 0;
	  target_architecture = arch;
	}
      break;
    }
}

/* Called if the user enters ``show architecture'' without an argument. */
static void show_architecture PARAMS ((char *, int));
static void
show_architecture (args, from_tty)
     char *args;
     int from_tty;
{
  const char *arch;
  arch = TARGET_ARCHITECTURE->printable_name;
  if (target_architecture_auto)
    printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
  else
    printf_filtered ("The target architecture is assumed to be %s\n", arch);
}

/* Called if the user enters ``set architecture'' with or without an
   argument. */
static void set_architecture PARAMS ((char *, int));
static void
set_architecture (args, from_tty)
     char *args;
     int from_tty;
{
  if (args == NULL)
    {
      printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
    }
  else if (strcmp (args, "auto") == 0)
    {
      target_architecture_auto = 1;
    }
  else
    {
      const struct bfd_arch_info *arch = bfd_scan_arch (args);
      if (arch != NULL)
	set_arch (arch, set_arch_manual);
      else
	printf_unfiltered ("Architecture `%s' not reconized.\n", args);
    }
}

/* Called if the user enters ``info architecture'' without an argument. */
static void info_architecture PARAMS ((char *, int));
static void
info_architecture (args, from_tty)
     char *args;
     int from_tty;
{
  enum bfd_architecture a;
  printf_filtered ("Available architectures are:\n");
  for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
    {
      const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
      if (ap != NULL)
	{
	  do
	    {
	      printf_filtered (" %s", ap->printable_name);
	      ap = ap->next;
	    }
	  while (ap != NULL);
	  printf_filtered ("\n");
	}
    }
}

/* Set the architecture from arch/machine */
void
set_architecture_from_arch_mach (arch, mach)
     enum bfd_architecture arch;
     unsigned long mach;
{
  const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
  if (wanted != NULL)
    set_arch (wanted, set_arch_manual);
  else
    fatal ("hardwired architecture/machine not reconized");
}

/* Set the architecture from a BFD */
static void set_architecture_from_file PARAMS ((bfd *));
static void
set_architecture_from_file (abfd)
     bfd *abfd;
{
  const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
  if (target_architecture_auto)
    {
      set_arch (wanted, set_arch_auto);
    }
  else if (wanted != target_architecture)
    {
      warning ("%s architecture file may be incompatible with %s target.",
	       wanted->printable_name,
	       target_architecture->printable_name);
    }
}


/* Disassembler */

/* Pointer to the target-dependent disassembly function.  */
int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *));
disassemble_info tm_print_insn_info;


/* Set the dynamic target-system-dependant parameters (architecture,
   byte-order) using information found in the BFD */

void
set_gdbarch_from_file (abfd)
     bfd *abfd;
{
  set_architecture_from_file (abfd);
  set_endian_from_file (abfd);
}


#if defined (CALL_DUMMY)
/* FIXME - this should go away */
LONGEST call_dummy_words[] = CALL_DUMMY;
int sizeof_call_dummy_words = sizeof (call_dummy_words);
#endif


extern void _initialize_gdbarch PARAMS ((void));
void
_initialize_gdbarch ()
{
  add_prefix_cmd ("endian", class_support, set_endian,
		  "Set endianness of target.",
		  &endianlist, "set endian ", 0, &setlist);
  add_cmd ("big", class_support, set_endian_big,
	   "Set target as being big endian.", &endianlist);
  add_cmd ("little", class_support, set_endian_little,
	   "Set target as being little endian.", &endianlist);
  add_cmd ("auto", class_support, set_endian_auto,
	   "Select target endianness automatically.", &endianlist);
  add_cmd ("endian", class_support, show_endian,
	   "Show endianness of target.", &showlist);

  add_cmd ("architecture", class_support, set_architecture,
	   "Set architecture of target.", &setlist);
  add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
  add_cmd ("architecture", class_support, show_architecture,
	   "Show architecture of target.", &showlist);
  add_cmd ("architecture", class_support, info_architecture,
	   "List supported target architectures", &infolist);

  INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
  tm_print_insn_info.flavour = bfd_target_unknown_flavour;
  tm_print_insn_info.read_memory_func = dis_asm_read_memory;
  tm_print_insn_info.memory_error_func = dis_asm_memory_error;
  tm_print_insn_info.print_address_func = dis_asm_print_address;

  add_show_from_set (add_set_cmd ("archdebug",
				  class_maintenance,
				  var_zinteger,
				  (char *)&gdbarch_debug,
				  "Set architecture debugging.\n\
When non-zero, architecture debugging is enabled.", &setlist),
		     &showlist);
}
Commit	Line	Data
c906108c	1	/* Semi-dynamic architecture support for GDB, the GNU debugger.
b83266a0	2	Copyright 1998-1999, Free Software Foundation, Inc.
c906108c SS	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	19
	20	#include "defs.h"
c906108c	21
7a292a7a SS	22	/* Just include everything in sight so that the every old definition
	23	of macro is visible. */
	24	#include "gdb_string.h"
	25	#include <ctype.h>
	26	#include "symtab.h"
	27	#include "frame.h"
	28	#include "inferior.h"
	29	#include "breakpoint.h"
	30	#include "wait.h"
	31	#include "gdbcore.h"
	32	#include "gdbcmd.h"
	33	#include "target.h"
	34	#include "gdbthread.h"
	35	#include "annotate.h"
	36	#include "symfile.h" /* for overlay functions */
	37	#include "symcat.h"
c906108c SS	38
	39
	40	/* Non-zero if we want to trace architecture code. */
	41
	42	#ifndef GDBARCH_DEBUG
	43	#define GDBARCH_DEBUG 0
	44	#endif
	45	int gdbarch_debug = GDBARCH_DEBUG;
	46
	47
	48	/* Functions to manipulate the endianness of the target. */
	49
	50	#ifdef TARGET_BYTE_ORDER_SELECTABLE
	51	/* compat - Catch old targets that expect a selectable byte-order to
	52	default to BIG_ENDIAN */
	53	#ifndef TARGET_BYTE_ORDER_DEFAULT
	54	#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
	55	#endif
	56	#endif
7a292a7a	57	#if !TARGET_BYTE_ORDER_SELECTABLE_P
c906108c SS	58	#ifndef TARGET_BYTE_ORDER_DEFAULT
	59	/* compat - Catch old non byte-order selectable targets that do not
	60	define TARGET_BYTE_ORDER_DEFAULT and instead expect
	61	TARGET_BYTE_ORDER to be used as the default. For targets that
	62	defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
	63	below will get a strange compiler warning. */
	64	#define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
	65	#endif
7a292a7a SS	66	#endif
	67	#ifndef TARGET_BYTE_ORDER_DEFAULT
	68	#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
	69	#endif
c906108c SS	70	int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
	71	int target_byte_order_auto = 1;
	72
	73	/* Chain containing the \"set endian\" commands. */
	74	static struct cmd_list_element *endianlist = NULL;
	75
	76	/* Called by ``show endian''. */
	77	static void show_endian PARAMS ((char *, int));
	78	static void
	79	show_endian (args, from_tty)
	80	char *args;
	81	int from_tty;
	82	{
	83	char *msg =
	84	(TARGET_BYTE_ORDER_AUTO
	85	? "The target endianness is set automatically (currently %s endian)\n"
	86	: "The target is assumed to be %s endian\n");
	87	printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
	88	}
	89
	90	/* Called if the user enters ``set endian'' without an argument. */
	91	static void set_endian PARAMS ((char *, int));
	92	static void
	93	set_endian (args, from_tty)
	94	char *args;
	95	int from_tty;
	96	{
	97	printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
	98	show_endian (args, from_tty);
	99	}
	100
	101	/* Called by ``set endian big''. */
	102	static void set_endian_big PARAMS ((char *, int));
	103	static void
	104	set_endian_big (args, from_tty)
	105	char *args;
	106	int from_tty;
	107	{
	108	if (TARGET_BYTE_ORDER_SELECTABLE_P)
	109	{
	110	target_byte_order = BIG_ENDIAN;
	111	target_byte_order_auto = 0;
	112	}
	113	else
	114	{
	115	printf_unfiltered ("Byte order is not selectable.");
	116	show_endian (args, from_tty);
	117	}
	118	}
	119
	120	/* Called by ``set endian little''. */
	121	static void set_endian_little PARAMS ((char *, int));
	122	static void
	123	set_endian_little (args, from_tty)
	124	char *args;
	125	int from_tty;
	126	{
	127	if (TARGET_BYTE_ORDER_SELECTABLE_P)
	128	{
	129	target_byte_order = LITTLE_ENDIAN;
	130	target_byte_order_auto = 0;
	131	}
	132	else
	133	{
134	printf_unfiltered ("Byte order is not selectable.");
135	show_endian (args, from_tty);
136	}
137	}
138
139	/* Called by ``set endian auto''. */
140	static void set_endian_auto PARAMS ((char *, int));
141	static void
142	set_endian_auto (args, from_tty)
143	char *args;
144	int from_tty;
145	{
146	if (TARGET_BYTE_ORDER_SELECTABLE_P)
147	{
148	target_byte_order_auto = 1;
149	}
150	else
151	{
152	printf_unfiltered ("Byte order is not selectable.");
153	show_endian (args, from_tty);
154	}
155	}
156
157	/* Set the endianness from a BFD. */
158	static void set_endian_from_file PARAMS ((bfd *));
159	static void
160	set_endian_from_file (abfd)
161	bfd *abfd;
162	{
163	if (TARGET_BYTE_ORDER_SELECTABLE_P)
164	{
165	int want;
166
167	if (bfd_big_endian (abfd))
168	want = BIG_ENDIAN;
169	else
170	want = LITTLE_ENDIAN;
171	if (TARGET_BYTE_ORDER_AUTO)
172	target_byte_order = want;
173	else if (TARGET_BYTE_ORDER != want)
174	warning ("%s endian file does not match %s endian target.",
175	want == BIG_ENDIAN ? "big" : "little",
176	TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
177	}
178	else
179	{
180	if (bfd_big_endian (abfd)
181	? TARGET_BYTE_ORDER != BIG_ENDIAN
182	: TARGET_BYTE_ORDER == BIG_ENDIAN)
183	warning ("%s endian file does not match %s endian target.",
184	bfd_big_endian (abfd) ? "big" : "little",
185	TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
186	}
187	}
188
189
190
191	/* Functions to manipulate the architecture of the target */
192
193	int target_architecture_auto = 1;
194	extern const struct bfd_arch_info bfd_default_arch_struct;
195	const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
196	int (target_architecture_hook) PARAMS ((const struct bfd_arch_info ap));
197
198	/* Do the real work of changing the current architecture */
b83266a0 SS	199
	200	static int arch_valid PARAMS ((const struct bfd_arch_info *arch));
	201	static int
	202	arch_ok (arch)
	203	const struct bfd_arch_info *arch;
	204	{
	205	/* Should be performing the more basic check that the binary is
	206	compatible with GDB. */
	207	/* Check with the target that the architecture is valid. */
	208	return (target_architecture_hook == NULL
	209	\|\| target_architecture_hook (arch));
	210	}
	211
7a292a7a	212	enum set_arch { set_arch_auto, set_arch_manual };
b83266a0	213
c906108c	214	static void
7a292a7a	215	set_arch (arch, type)
c906108c	216	const struct bfd_arch_info *arch;
7a292a7a	217	enum set_arch type;
c906108c	218	{
7a292a7a	219	switch (type)
c906108c	220	{
7a292a7a	221	case set_arch_auto:
b83266a0	222	if (!arch_ok (arch))
7a292a7a SS	223	warning ("Target may not support %s architecture",
7a292a7a SS	224	arch->printable_name);
c906108c	225	target_architecture = arch;
7a292a7a SS	226	break;
7a292a7a SS	227	case set_arch_manual:
b83266a0	228	if (!arch_ok (arch))
7a292a7a SS	229	{
	230	printf_unfiltered ("Target does not support `%s' architecture.\n",
	231	arch->printable_name);
	232	}
	233	else
	234	{
	235	target_architecture_auto = 0;
	236	target_architecture = arch;
	237	}
	238	break;
c906108c SS	239	}
	240	}
	241
	242	/* Called if the user enters ``show architecture'' without an argument. */
	243	static void show_architecture PARAMS ((char *, int));
	244	static void
	245	show_architecture (args, from_tty)
	246	char *args;
	247	int from_tty;
	248	{
	249	const char *arch;
	250	arch = TARGET_ARCHITECTURE->printable_name;
	251	if (target_architecture_auto)
	252	printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
	253	else
	254	printf_filtered ("The target architecture is assumed to be %s\n", arch);
	255	}
	256
	257	/* Called if the user enters ``set architecture'' with or without an
	258	argument. */
	259	static void set_architecture PARAMS ((char *, int));
	260	static void
	261	set_architecture (args, from_tty)
	262	char *args;
	263	int from_tty;
	264	{
	265	if (args == NULL)
	266	{
	267	printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
	268	}
	269	else if (strcmp (args, "auto") == 0)
	270	{
	271	target_architecture_auto = 1;
	272	}
	273	else
	274	{
	275	const struct bfd_arch_info *arch = bfd_scan_arch (args);
	276	if (arch != NULL)
7a292a7a	277	set_arch (arch, set_arch_manual);
c906108c SS	278	else
	279	printf_unfiltered ("Architecture `%s' not reconized.\n", args);
	280	}
	281	}
	282
	283	/* Called if the user enters ``info architecture'' without an argument. */
	284	static void info_architecture PARAMS ((char *, int));
	285	static void
	286	info_architecture (args, from_tty)
	287	char *args;
	288	int from_tty;
	289	{
	290	enum bfd_architecture a;
	291	printf_filtered ("Available architectures are:\n");
	292	for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
	293	{
	294	const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
	295	if (ap != NULL)
	296	{
	297	do
	298	{
	299	printf_filtered (" %s", ap->printable_name);
	300	ap = ap->next;
	301	}
	302	while (ap != NULL);
	303	printf_filtered ("\n");
	304	}
	305	}
	306	}
	307
	308	/* Set the architecture from arch/machine */
	309	void
	310	set_architecture_from_arch_mach (arch, mach)
	311	enum bfd_architecture arch;
	312	unsigned long mach;
	313	{
	314	const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
	315	if (wanted != NULL)
7a292a7a	316	set_arch (wanted, set_arch_manual);
c906108c SS	317	else
	318	fatal ("hardwired architecture/machine not reconized");
	319	}
	320
	321	/* Set the architecture from a BFD */
	322	static void set_architecture_from_file PARAMS ((bfd *));
	323	static void
	324	set_architecture_from_file (abfd)
	325	bfd *abfd;
	326	{
	327	const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
	328	if (target_architecture_auto)
	329	{
7a292a7a	330	set_arch (wanted, set_arch_auto);
c906108c SS	331	}
	332	else if (wanted != target_architecture)
	333	{
	334	warning ("%s architecture file may be incompatible with %s target.",
	335	wanted->printable_name,
	336	target_architecture->printable_name);
	337	}
	338	}
	339
	340
	341
	342	/* Disassembler */
	343
	344	/* Pointer to the target-dependent disassembly function. */
	345	int (tm_print_insn) PARAMS ((bfd_vma, disassemble_info ));
	346	disassemble_info tm_print_insn_info;
	347
	348
	349
	350	/* Set the dynamic target-system-dependant parameters (architecture,
	351	byte-order) using information found in the BFD */
	352
	353	void
	354	set_gdbarch_from_file (abfd)
	355	bfd *abfd;
	356	{
	357	set_architecture_from_file (abfd);
	358	set_endian_from_file (abfd);
	359	}
	360
	361
7a292a7a SS	362	#if defined (CALL_DUMMY)
	363	/* FIXME - this should go away */
	364	LONGEST call_dummy_words[] = CALL_DUMMY;
	365	int sizeof_call_dummy_words = sizeof (call_dummy_words);
	366	#endif
	367
	368
c906108c SS	369	extern void _initialize_gdbarch PARAMS ((void));
	370	void
	371	_initialize_gdbarch ()
	372	{
	373	add_prefix_cmd ("endian", class_support, set_endian,
	374	"Set endianness of target.",
	375	&endianlist, "set endian ", 0, &setlist);
	376	add_cmd ("big", class_support, set_endian_big,
	377	"Set target as being big endian.", &endianlist);
	378	add_cmd ("little", class_support, set_endian_little,
	379	"Set target as being little endian.", &endianlist);
	380	add_cmd ("auto", class_support, set_endian_auto,
	381	"Select target endianness automatically.", &endianlist);
	382	add_cmd ("endian", class_support, show_endian,
	383	"Show endianness of target.", &showlist);
	384
	385	add_cmd ("architecture", class_support, set_architecture,
	386	"Set architecture of target.", &setlist);
	387	add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
	388	add_cmd ("architecture", class_support, show_architecture,
	389	"Show architecture of target.", &showlist);
	390	add_cmd ("architecture", class_support, info_architecture,
	391	"List supported target architectures", &infolist);
	392
	393	INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
	394	tm_print_insn_info.flavour = bfd_target_unknown_flavour;
	395	tm_print_insn_info.read_memory_func = dis_asm_read_memory;
	396	tm_print_insn_info.memory_error_func = dis_asm_memory_error;
	397	tm_print_insn_info.print_address_func = dis_asm_print_address;
	398
c906108c SS	399	add_show_from_set (add_set_cmd ("archdebug",
	400	class_maintenance,
	401	var_zinteger,
	402	(char *)&gdbarch_debug,
	403	"Set architecture debugging.\n\
	404	When non-zero, architecture debugging is enabled.", &setlist),
	405	&showlist);
c906108c	406	}