1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
25 #include "arch-utils.h"
28 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
29 #include "gdb_string.h"
31 #include "gdb_assert.h"
32 #include "sim-regno.h"
35 #include "target-descriptions.h"
39 #include "floatformat.h"
41 /* Implementation of extract return value that grubs around in the
44 legacy_extract_return_value (struct type
*type
, struct regcache
*regcache
,
47 gdb_byte
*registers
= deprecated_grub_regcache_for_registers (regcache
);
48 gdb_byte
*buf
= valbuf
;
49 DEPRECATED_EXTRACT_RETURN_VALUE (type
, registers
, buf
); /* OK */
52 /* Implementation of store return value that grubs the register cache.
53 Takes a local copy of the buffer to avoid const problems. */
55 legacy_store_return_value (struct type
*type
, struct regcache
*regcache
,
58 gdb_byte
*b
= alloca (TYPE_LENGTH (type
));
59 gdb_assert (regcache
== current_regcache
);
60 memcpy (b
, buf
, TYPE_LENGTH (type
));
61 DEPRECATED_STORE_RETURN_VALUE (type
, b
);
65 always_use_struct_convention (int gcc_p
, struct type
*value_type
)
70 enum return_value_convention
71 legacy_return_value (struct gdbarch
*gdbarch
, struct type
*valtype
,
72 struct regcache
*regcache
, gdb_byte
*readbuf
,
73 const gdb_byte
*writebuf
)
75 /* NOTE: cagney/2004-06-13: The gcc_p parameter to
76 USE_STRUCT_CONVENTION isn't used. */
77 int struct_return
= ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
78 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
79 || TYPE_CODE (valtype
) == TYPE_CODE_ARRAY
)
80 && DEPRECATED_USE_STRUCT_CONVENTION (0, valtype
));
84 gdb_assert (!struct_return
);
85 /* NOTE: cagney/2004-06-13: See stack.c:return_command. Old
86 architectures don't expect STORE_RETURN_VALUE to handle small
87 structures. Should not be called with such types. */
88 gdb_assert (TYPE_CODE (valtype
) != TYPE_CODE_STRUCT
89 && TYPE_CODE (valtype
) != TYPE_CODE_UNION
);
90 STORE_RETURN_VALUE (valtype
, regcache
, writebuf
);
95 gdb_assert (!struct_return
);
96 EXTRACT_RETURN_VALUE (valtype
, regcache
, readbuf
);
100 return RETURN_VALUE_STRUCT_CONVENTION
;
102 return RETURN_VALUE_REGISTER_CONVENTION
;
106 legacy_register_sim_regno (int regnum
)
108 /* Only makes sense to supply raw registers. */
109 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
);
110 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
111 suspected that some GDB/SIM combinations may rely on this
112 behavour. The default should be one2one_register_sim_regno
114 if (REGISTER_NAME (regnum
) != NULL
115 && REGISTER_NAME (regnum
)[0] != '\0')
118 return LEGACY_SIM_REGNO_IGNORE
;
122 generic_skip_trampoline_code (CORE_ADDR pc
)
128 generic_skip_solib_resolver (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
134 generic_in_solib_return_trampoline (CORE_ADDR pc
, char *name
)
140 generic_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
146 generic_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
147 struct regcache
*regcache
,
148 CORE_ADDR gdb_addr
, int gdb_len
,
149 CORE_ADDR
* rem_addr
, int *rem_len
)
151 *rem_addr
= gdb_addr
;
155 /* Helper functions for INNER_THAN */
158 core_addr_lessthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
164 core_addr_greaterthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
170 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
172 const struct floatformat
*
173 default_float_format (struct gdbarch
*gdbarch
)
175 int byte_order
= gdbarch_byte_order (gdbarch
);
179 return &floatformat_ieee_single_big
;
180 case BFD_ENDIAN_LITTLE
:
181 return &floatformat_ieee_single_little
;
183 internal_error (__FILE__
, __LINE__
,
184 _("default_float_format: bad byte order"));
189 const struct floatformat
*
190 default_double_format (struct gdbarch
*gdbarch
)
192 int byte_order
= gdbarch_byte_order (gdbarch
);
196 return &floatformat_ieee_double_big
;
197 case BFD_ENDIAN_LITTLE
:
198 return &floatformat_ieee_double_little
;
200 internal_error (__FILE__
, __LINE__
,
201 _("default_double_format: bad byte order"));
205 /* Misc helper functions for targets. */
208 core_addr_identity (CORE_ADDR addr
)
214 convert_from_func_ptr_addr_identity (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
215 struct target_ops
*targ
)
221 no_op_reg_to_regnum (int reg
)
227 default_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
233 default_coff_make_msymbol_special (int val
, struct minimal_symbol
*msym
)
239 cannot_register_not (int regnum
)
244 /* Legacy version of target_virtual_frame_pointer(). Assumes that
245 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
249 legacy_virtual_frame_pointer (CORE_ADDR pc
,
251 LONGEST
*frame_offset
)
253 /* FIXME: cagney/2002-09-13: This code is used when identifying the
254 frame pointer of the current PC. It is assuming that a single
255 register and an offset can determine this. I think it should
256 instead generate a byte code expression as that would work better
257 with things like Dwarf2's CFI. */
258 if (DEPRECATED_FP_REGNUM
>= 0 && DEPRECATED_FP_REGNUM
< NUM_REGS
)
259 *frame_regnum
= DEPRECATED_FP_REGNUM
;
260 else if (SP_REGNUM
>= 0 && SP_REGNUM
< NUM_REGS
)
261 *frame_regnum
= SP_REGNUM
;
263 /* Should this be an internal error? I guess so, it is reflecting
264 an architectural limitation in the current design. */
265 internal_error (__FILE__
, __LINE__
, _("No virtual frame pointer available"));
269 /* Assume the world is sane, every register's virtual and real size
273 generic_register_size (int regnum
)
275 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
276 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch
, regnum
));
279 /* Assume all registers are adjacent. */
282 generic_register_byte (int regnum
)
286 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
288 for (i
= 0; i
< regnum
; i
++)
290 byte
+= generic_register_size (i
);
297 legacy_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
299 #if defined (DEPRECATED_IN_SIGTRAMP)
300 return DEPRECATED_IN_SIGTRAMP (pc
, name
);
302 return name
&& strcmp ("_sigtramp", name
) == 0;
307 generic_convert_register_p (int regnum
, struct type
*type
)
313 default_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
315 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
316 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, type
))
318 CHECK_TYPEDEF (type
);
320 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
321 || TYPE_CODE (type
) == TYPE_CODE_UNION
322 || TYPE_CODE (type
) == TYPE_CODE_SET
323 || TYPE_CODE (type
) == TYPE_CODE_BITSTRING
);
330 generic_instruction_nullified (struct gdbarch
*gdbarch
,
331 struct regcache
*regcache
)
337 /* Functions to manipulate the endianness of the target. */
339 static int target_byte_order_user
= BFD_ENDIAN_UNKNOWN
;
341 static const char endian_big
[] = "big";
342 static const char endian_little
[] = "little";
343 static const char endian_auto
[] = "auto";
344 static const char *endian_enum
[] =
351 static const char *set_endian_string
;
353 /* Called by ``show endian''. */
356 show_endian (struct ui_file
*file
, int from_tty
, struct cmd_list_element
*c
,
359 if (target_byte_order_user
!= BFD_ENDIAN_UNKNOWN
)
360 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
361 fprintf_unfiltered (file
, _("The target endianness is set automatically "
362 "(currently big endian)\n"));
364 fprintf_unfiltered (file
, _("The target endianness is set automatically "
365 "(currently little endian)\n"));
367 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
368 fprintf_unfiltered (file
,
369 _("The target is assumed to be big endian\n"));
371 fprintf_unfiltered (file
,
372 _("The target is assumed to be little endian\n"));
376 set_endian (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
378 struct gdbarch_info info
;
380 gdbarch_info_init (&info
);
382 if (set_endian_string
== endian_auto
)
384 target_byte_order_user
= BFD_ENDIAN_UNKNOWN
;
385 if (! gdbarch_update_p (info
))
386 internal_error (__FILE__
, __LINE__
,
387 _("set_endian: architecture update failed"));
389 else if (set_endian_string
== endian_little
)
391 info
.byte_order
= BFD_ENDIAN_LITTLE
;
392 if (! gdbarch_update_p (info
))
393 printf_unfiltered (_("Little endian target not supported by GDB\n"));
395 target_byte_order_user
= BFD_ENDIAN_LITTLE
;
397 else if (set_endian_string
== endian_big
)
399 info
.byte_order
= BFD_ENDIAN_BIG
;
400 if (! gdbarch_update_p (info
))
401 printf_unfiltered (_("Big endian target not supported by GDB\n"));
403 target_byte_order_user
= BFD_ENDIAN_BIG
;
406 internal_error (__FILE__
, __LINE__
,
407 _("set_endian: bad value"));
409 show_endian (gdb_stdout
, from_tty
, NULL
, NULL
);
412 /* Given SELECTED, a currently selected BFD architecture, and
413 FROM_TARGET, a BFD architecture reported by the target description,
414 return what architecture to use. Either may be NULL; if both are
415 specified, we use the more specific. If the two are obviously
416 incompatible, warn the user. */
418 static const struct bfd_arch_info
*
419 choose_architecture_for_target (const struct bfd_arch_info
*selected
,
420 const struct bfd_arch_info
*from_target
)
422 const struct bfd_arch_info
*compat1
, *compat2
;
424 if (selected
== NULL
)
427 if (from_target
== NULL
)
430 /* struct bfd_arch_info objects are singletons: that is, there's
431 supposed to be exactly one instance for a given machine. So you
432 can tell whether two are equivalent by comparing pointers. */
433 if (from_target
== selected
)
436 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
437 incompatible. But if they are compatible, it returns the 'more
438 featureful' of the two arches. That is, if A can run code
439 written for B, but B can't run code written for A, then it'll
442 Some targets (e.g. MIPS as of 2006-12-04) don't fully
443 implement this, instead always returning NULL or the first
444 argument. We detect that case by checking both directions. */
446 compat1
= selected
->compatible (selected
, from_target
);
447 compat2
= from_target
->compatible (from_target
, selected
);
449 if (compat1
== NULL
&& compat2
== NULL
)
451 warning (_("Selected architecture %s is not compatible "
452 "with reported target architecture %s"),
453 selected
->printable_name
, from_target
->printable_name
);
461 if (compat1
== compat2
)
464 /* If the two didn't match, but one of them was a default architecture,
465 assume the more specific one is correct. This handles the case
466 where an executable or target description just says "mips", but
467 the other knows which MIPS variant. */
468 if (compat1
->the_default
)
470 if (compat2
->the_default
)
473 /* We have no idea which one is better. This is a bug, but not
474 a critical problem; warn the user. */
475 warning (_("Selected architecture %s is ambiguous with "
476 "reported target architecture %s"),
477 selected
->printable_name
, from_target
->printable_name
);
481 /* Functions to manipulate the architecture of the target */
483 enum set_arch
{ set_arch_auto
, set_arch_manual
};
485 static const struct bfd_arch_info
*target_architecture_user
;
487 static const char *set_architecture_string
;
490 selected_architecture_name (void)
492 if (target_architecture_user
== NULL
)
495 return set_architecture_string
;
498 /* Called if the user enters ``show architecture'' without an
502 show_architecture (struct ui_file
*file
, int from_tty
,
503 struct cmd_list_element
*c
, const char *value
)
506 arch
= TARGET_ARCHITECTURE
->printable_name
;
507 if (target_architecture_user
== NULL
)
508 fprintf_filtered (file
, _("\
509 The target architecture is set automatically (currently %s)\n"), arch
);
511 fprintf_filtered (file
, _("\
512 The target architecture is assumed to be %s\n"), arch
);
516 /* Called if the user enters ``set architecture'' with or without an
520 set_architecture (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
522 struct gdbarch_info info
;
524 gdbarch_info_init (&info
);
526 if (strcmp (set_architecture_string
, "auto") == 0)
528 target_architecture_user
= NULL
;
529 if (!gdbarch_update_p (info
))
530 internal_error (__FILE__
, __LINE__
,
531 _("could not select an architecture automatically"));
535 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
536 if (info
.bfd_arch_info
== NULL
)
537 internal_error (__FILE__
, __LINE__
,
538 _("set_architecture: bfd_scan_arch failed"));
539 if (gdbarch_update_p (info
))
540 target_architecture_user
= info
.bfd_arch_info
;
542 printf_unfiltered (_("Architecture `%s' not recognized.\n"),
543 set_architecture_string
);
545 show_architecture (gdb_stdout
, from_tty
, NULL
, NULL
);
548 /* Try to select a global architecture that matches "info". Return
549 non-zero if the attempt succeds. */
551 gdbarch_update_p (struct gdbarch_info info
)
553 struct gdbarch
*new_gdbarch
= gdbarch_find_by_info (info
);
555 /* If there no architecture by that name, reject the request. */
556 if (new_gdbarch
== NULL
)
559 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update_p: "
560 "Architecture not found\n");
564 /* If it is the same old architecture, accept the request (but don't
566 if (new_gdbarch
== current_gdbarch
)
569 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update_p: "
570 "Architecture 0x%08lx (%s) unchanged\n",
572 gdbarch_bfd_arch_info (new_gdbarch
)->printable_name
);
576 /* It's a new architecture, swap it in. */
578 fprintf_unfiltered (gdb_stdlog
, "gdbarch_update_p: "
579 "New architecture 0x%08lx (%s) selected\n",
581 gdbarch_bfd_arch_info (new_gdbarch
)->printable_name
);
582 deprecated_current_gdbarch_select_hack (new_gdbarch
);
587 /* Return the architecture for ABFD. If no suitable architecture
588 could be find, return NULL. */
591 gdbarch_from_bfd (bfd
*abfd
)
593 struct gdbarch
*old_gdbarch
= current_gdbarch
;
594 struct gdbarch
*new_gdbarch
;
595 struct gdbarch_info info
;
597 /* If we call gdbarch_find_by_info without filling in info.abfd,
598 then it will use the global exec_bfd. That's fine if we don't
599 have one of those either. And that's the only time we should
600 reach here with a NULL ABFD argument - when we are discarding
602 gdb_assert (abfd
!= NULL
|| exec_bfd
== NULL
);
604 gdbarch_info_init (&info
);
606 return gdbarch_find_by_info (info
);
609 /* Set the dynamic target-system-dependent parameters (architecture,
610 byte-order) using information found in the BFD */
613 set_gdbarch_from_file (bfd
*abfd
)
615 struct gdbarch
*gdbarch
;
617 gdbarch
= gdbarch_from_bfd (abfd
);
619 error (_("Architecture of file not recognized."));
620 deprecated_current_gdbarch_select_hack (gdbarch
);
623 /* Initialize the current architecture. Update the ``set
624 architecture'' command so that it specifies a list of valid
627 #ifdef DEFAULT_BFD_ARCH
628 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
629 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
631 static const bfd_arch_info_type
*default_bfd_arch
;
634 #ifdef DEFAULT_BFD_VEC
635 extern const bfd_target DEFAULT_BFD_VEC
;
636 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
638 static const bfd_target
*default_bfd_vec
;
641 static int default_byte_order
= BFD_ENDIAN_UNKNOWN
;
644 initialize_current_architecture (void)
646 const char **arches
= gdbarch_printable_names ();
648 /* determine a default architecture and byte order. */
649 struct gdbarch_info info
;
650 gdbarch_info_init (&info
);
652 /* Find a default architecture. */
653 if (default_bfd_arch
== NULL
)
655 /* Choose the architecture by taking the first one
657 const char *chosen
= arches
[0];
659 for (arch
= arches
; *arch
!= NULL
; arch
++)
661 if (strcmp (*arch
, chosen
) < 0)
665 internal_error (__FILE__
, __LINE__
,
666 _("initialize_current_architecture: No arch"));
667 default_bfd_arch
= bfd_scan_arch (chosen
);
668 if (default_bfd_arch
== NULL
)
669 internal_error (__FILE__
, __LINE__
,
670 _("initialize_current_architecture: Arch not found"));
673 info
.bfd_arch_info
= default_bfd_arch
;
675 /* Take several guesses at a byte order. */
676 if (default_byte_order
== BFD_ENDIAN_UNKNOWN
677 && default_bfd_vec
!= NULL
)
679 /* Extract BFD's default vector's byte order. */
680 switch (default_bfd_vec
->byteorder
)
683 default_byte_order
= BFD_ENDIAN_BIG
;
685 case BFD_ENDIAN_LITTLE
:
686 default_byte_order
= BFD_ENDIAN_LITTLE
;
692 if (default_byte_order
== BFD_ENDIAN_UNKNOWN
)
694 /* look for ``*el-*'' in the target name. */
696 chp
= strchr (target_name
, '-');
698 && chp
- 2 >= target_name
699 && strncmp (chp
- 2, "el", 2) == 0)
700 default_byte_order
= BFD_ENDIAN_LITTLE
;
702 if (default_byte_order
== BFD_ENDIAN_UNKNOWN
)
704 /* Wire it to big-endian!!! */
705 default_byte_order
= BFD_ENDIAN_BIG
;
708 info
.byte_order
= default_byte_order
;
710 if (! gdbarch_update_p (info
))
711 internal_error (__FILE__
, __LINE__
,
712 _("initialize_current_architecture: Selection of "
713 "initial architecture failed"));
715 /* Create the ``set architecture'' command appending ``auto'' to the
716 list of architectures. */
718 struct cmd_list_element
*c
;
719 /* Append ``auto''. */
721 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
722 arches
= xrealloc (arches
, sizeof (char*) * (nr
+ 2));
723 arches
[nr
+ 0] = "auto";
724 arches
[nr
+ 1] = NULL
;
725 add_setshow_enum_cmd ("architecture", class_support
,
726 arches
, &set_architecture_string
, _("\
727 Set architecture of target."), _("\
728 Show architecture of target."), NULL
,
729 set_architecture
, show_architecture
,
730 &setlist
, &showlist
);
731 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
736 /* Initialize a gdbarch info to values that will be automatically
737 overridden. Note: Originally, this ``struct info'' was initialized
738 using memset(0). Unfortunately, that ran into problems, namely
739 BFD_ENDIAN_BIG is zero. An explicit initialization function that
740 can explicitly set each field to a well defined value is used. */
743 gdbarch_info_init (struct gdbarch_info
*info
)
745 memset (info
, 0, sizeof (struct gdbarch_info
));
746 info
->byte_order
= BFD_ENDIAN_UNKNOWN
;
747 info
->osabi
= GDB_OSABI_UNINITIALIZED
;
750 /* Similar to init, but this time fill in the blanks. Information is
751 obtained from the global "set ..." options and explicitly
752 initialized INFO fields. */
755 gdbarch_info_fill (struct gdbarch_info
*info
)
757 /* Check for the current file. */
758 if (info
->abfd
== NULL
)
759 info
->abfd
= exec_bfd
;
761 /* Check for the current target description. */
762 if (info
->target_desc
== NULL
)
763 info
->target_desc
= target_current_description ();
765 /* "(gdb) set architecture ...". */
766 if (info
->bfd_arch_info
== NULL
767 && target_architecture_user
)
768 info
->bfd_arch_info
= target_architecture_user
;
770 if (info
->bfd_arch_info
== NULL
771 && info
->abfd
!= NULL
772 && bfd_get_arch (info
->abfd
) != bfd_arch_unknown
773 && bfd_get_arch (info
->abfd
) != bfd_arch_obscure
)
774 info
->bfd_arch_info
= bfd_get_arch_info (info
->abfd
);
775 /* From the target. */
776 if (info
->target_desc
!= NULL
)
777 info
->bfd_arch_info
= choose_architecture_for_target
778 (info
->bfd_arch_info
, tdesc_architecture (info
->target_desc
));
779 /* From the default. */
780 if (info
->bfd_arch_info
== NULL
)
781 info
->bfd_arch_info
= default_bfd_arch
;
783 /* "(gdb) set byte-order ...". */
784 if (info
->byte_order
== BFD_ENDIAN_UNKNOWN
785 && target_byte_order_user
!= BFD_ENDIAN_UNKNOWN
)
786 info
->byte_order
= target_byte_order_user
;
787 /* From the INFO struct. */
788 if (info
->byte_order
== BFD_ENDIAN_UNKNOWN
789 && info
->abfd
!= NULL
)
790 info
->byte_order
= (bfd_big_endian (info
->abfd
) ? BFD_ENDIAN_BIG
791 : bfd_little_endian (info
->abfd
) ? BFD_ENDIAN_LITTLE
792 : BFD_ENDIAN_UNKNOWN
);
793 /* From the default. */
794 if (info
->byte_order
== BFD_ENDIAN_UNKNOWN
)
795 info
->byte_order
= default_byte_order
;
797 /* "(gdb) set osabi ...". Handled by gdbarch_lookup_osabi. */
798 if (info
->osabi
== GDB_OSABI_UNINITIALIZED
)
799 info
->osabi
= gdbarch_lookup_osabi (info
->abfd
);
801 /* Must have at least filled in the architecture. */
802 gdb_assert (info
->bfd_arch_info
!= NULL
);
807 extern initialize_file_ftype _initialize_gdbarch_utils
; /* -Wmissing-prototypes */
810 _initialize_gdbarch_utils (void)
812 struct cmd_list_element
*c
;
813 add_setshow_enum_cmd ("endian", class_support
,
814 endian_enum
, &set_endian_string
, _("\
815 Set endianness of target."), _("\
816 Show endianness of target."), NULL
,
817 set_endian
, show_endian
,
818 &setlist
, &showlist
);