1 /* Dynamic architecture support for GDB, the GNU debugger.
2 Copyright 1998-1999, Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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,
19 Boston, MA 02111-1307, USA. */
25 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
27 /* Just include everything in sight so that the every old definition
28 of macro is visible. */
29 #include "gdb_string.h"
34 #include "breakpoint.h"
39 #include "gdbthread.h"
41 #include "symfile.h" /* for overlay functions */
46 #include "floatformat.h"
48 /* Convenience macro for allocting typesafe memory. */
51 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
55 /* Use the program counter to determine the contents and size
56 of a breakpoint instruction. If no target-dependent macro
57 BREAKPOINT_FROM_PC has been defined to implement this function,
58 assume that the breakpoint doesn't depend on the PC, and
59 use the values of the BIG_BREAKPOINT and LITTLE_BREAKPOINT macros.
60 Return a pointer to a string of bytes that encode a breakpoint
61 instruction, stores the length of the string to *lenptr,
62 and optionally adjust the pc to point to the correct memory location
63 for inserting the breakpoint. */
66 legacy_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr)
68 /* {BIG_,LITTLE_}BREAKPOINT is the sequence of bytes we insert for a
69 breakpoint. On some machines, breakpoints are handled by the
70 target environment and we don't have to worry about them here. */
72 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
74 static unsigned char big_break_insn[] = BIG_BREAKPOINT;
75 *lenptr = sizeof (big_break_insn);
76 return big_break_insn;
79 #ifdef LITTLE_BREAKPOINT
80 if (TARGET_BYTE_ORDER != BIG_ENDIAN)
82 static unsigned char little_break_insn[] = LITTLE_BREAKPOINT;
83 *lenptr = sizeof (little_break_insn);
84 return little_break_insn;
89 static unsigned char break_insn[] = BREAKPOINT;
90 *lenptr = sizeof (break_insn);
99 generic_frameless_function_invocation_not (struct frame_info *fi)
105 generic_return_value_on_stack_not (struct type *type)
111 legacy_register_name (int i)
113 #ifdef REGISTER_NAMES
114 static char *names[] = REGISTER_NAMES;
115 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
120 internal_error ("legacy_register_name: called.");
125 #if defined (CALL_DUMMY)
126 LONGEST legacy_call_dummy_words[] = CALL_DUMMY;
128 LONGEST legacy_call_dummy_words[1];
130 int legacy_sizeof_call_dummy_words = sizeof (legacy_call_dummy_words);
133 generic_remote_translate_xfer_address (CORE_ADDR gdb_addr, int gdb_len,
134 CORE_ADDR * rem_addr, int *rem_len)
136 *rem_addr = gdb_addr;
141 generic_prologue_frameless_p (CORE_ADDR ip)
143 #ifdef SKIP_PROLOGUE_FRAMELESS_P
144 return ip == SKIP_PROLOGUE_FRAMELESS_P (ip);
146 return ip == SKIP_PROLOGUE (ip);
151 /* Helper functions for INNER_THAN */
154 core_addr_lessthan (CORE_ADDR lhs, CORE_ADDR rhs)
160 core_addr_greaterthan (CORE_ADDR lhs, CORE_ADDR rhs)
166 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
168 const struct floatformat *
169 default_float_format (struct gdbarch *gdbarch)
172 int byte_order = gdbarch_byte_order (gdbarch);
174 int byte_order = TARGET_BYTE_ORDER;
179 return &floatformat_ieee_single_big;
181 return &floatformat_ieee_single_little;
183 internal_error ("default_float_format: bad byte order");
188 const struct floatformat *
189 default_double_format (struct gdbarch *gdbarch)
192 int byte_order = gdbarch_byte_order (gdbarch);
194 int byte_order = TARGET_BYTE_ORDER;
199 return &floatformat_ieee_double_big;
201 return &floatformat_ieee_double_little;
203 internal_error ("default_double_format: bad byte order");
207 /* Misc helper functions for targets. */
210 frame_num_args_unknown (struct frame_info *fi)
217 generic_register_convertible_not (int num)
224 default_register_sim_regno (int num)
229 /* Functions to manipulate the endianness of the target. */
231 #ifdef TARGET_BYTE_ORDER_SELECTABLE
232 /* compat - Catch old targets that expect a selectable byte-order to
233 default to BIG_ENDIAN */
234 #ifndef TARGET_BYTE_ORDER_DEFAULT
235 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
238 #if !TARGET_BYTE_ORDER_SELECTABLE_P
239 #ifndef TARGET_BYTE_ORDER_DEFAULT
240 /* compat - Catch old non byte-order selectable targets that do not
241 define TARGET_BYTE_ORDER_DEFAULT and instead expect
242 TARGET_BYTE_ORDER to be used as the default. For targets that
243 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
244 below will get a strange compiler warning. */
245 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
248 #ifndef TARGET_BYTE_ORDER_DEFAULT
249 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
251 /* ``target_byte_order'' is only used when non- multi-arch.
252 Multi-arch targets obtain the current byte order using
253 TARGET_BYTE_ORDER which is controlled by gdbarch.*. */
254 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
255 int target_byte_order_auto = 1;
257 static const char endian_big[] = "big";
258 static const char endian_little[] = "little";
259 static const char endian_auto[] = "auto";
260 static const char *endian_enum[] =
267 static const char *set_endian_string;
269 /* Called by ``show endian''. */
272 show_endian (char *args, int from_tty)
274 if (TARGET_BYTE_ORDER_AUTO)
275 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
276 (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
278 printf_unfiltered ("The target is assumed to be %s endian\n",
279 (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
283 set_endian (char *ignore_args, int from_tty, struct cmd_list_element *c)
285 if (!TARGET_BYTE_ORDER_SELECTABLE_P)
287 printf_unfiltered ("Byte order is not selectable.");
289 else if (set_endian_string == endian_auto)
291 target_byte_order_auto = 1;
293 else if (set_endian_string == endian_little)
295 target_byte_order_auto = 0;
298 struct gdbarch_info info;
299 memset (&info, 0, sizeof info);
300 info.byte_order = LITTLE_ENDIAN;
301 if (! gdbarch_update_p (info))
303 printf_unfiltered ("Little endian target not supported by GDB\n");
308 target_byte_order = LITTLE_ENDIAN;
311 else if (set_endian_string == endian_big)
313 target_byte_order_auto = 0;
316 struct gdbarch_info info;
317 memset (&info, 0, sizeof info);
318 info.byte_order = BIG_ENDIAN;
319 if (! gdbarch_update_p (info))
321 printf_unfiltered ("Big endian target not supported by GDB\n");
326 target_byte_order = BIG_ENDIAN;
330 internal_error ("set_endian: bad value");
331 show_endian (NULL, from_tty);
334 /* Set the endianness from a BFD. */
337 set_endian_from_file (bfd *abfd)
340 internal_error ("set_endian_from_file: not for multi-arch");
341 if (TARGET_BYTE_ORDER_SELECTABLE_P)
345 if (bfd_big_endian (abfd))
348 want = LITTLE_ENDIAN;
349 if (TARGET_BYTE_ORDER_AUTO)
350 target_byte_order = want;
351 else if (TARGET_BYTE_ORDER != want)
352 warning ("%s endian file does not match %s endian target.",
353 want == BIG_ENDIAN ? "big" : "little",
354 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
358 if (bfd_big_endian (abfd)
359 ? TARGET_BYTE_ORDER != BIG_ENDIAN
360 : TARGET_BYTE_ORDER == BIG_ENDIAN)
361 warning ("%s endian file does not match %s endian target.",
362 bfd_big_endian (abfd) ? "big" : "little",
363 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
368 /* Functions to manipulate the architecture of the target */
370 enum set_arch { set_arch_auto, set_arch_manual };
372 int target_architecture_auto = 1;
374 const char *set_architecture_string;
376 /* Old way of changing the current architecture. */
378 extern const struct bfd_arch_info bfd_default_arch_struct;
379 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
380 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
383 arch_ok (const struct bfd_arch_info *arch)
386 internal_error ("arch_ok: not multi-arched");
387 /* Should be performing the more basic check that the binary is
388 compatible with GDB. */
389 /* Check with the target that the architecture is valid. */
390 return (target_architecture_hook == NULL
391 || target_architecture_hook (arch));
395 set_arch (const struct bfd_arch_info *arch,
399 internal_error ("set_arch: not multi-arched");
404 warning ("Target may not support %s architecture",
405 arch->printable_name);
406 target_architecture = arch;
408 case set_arch_manual:
411 printf_unfiltered ("Target does not support `%s' architecture.\n",
412 arch->printable_name);
416 target_architecture_auto = 0;
417 target_architecture = arch;
422 gdbarch_dump (current_gdbarch, gdb_stdlog);
425 /* Set the architecture from arch/machine (deprecated) */
428 set_architecture_from_arch_mach (enum bfd_architecture arch,
431 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
433 internal_error ("set_architecture_from_arch_mach: not multi-arched");
435 set_arch (wanted, set_arch_manual);
437 internal_error ("gdbarch: hardwired architecture/machine not reconized");
440 /* Set the architecture from a BFD (deprecated) */
443 set_architecture_from_file (bfd *abfd)
445 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
447 internal_error ("set_architecture_from_file: not multi-arched");
448 if (target_architecture_auto)
450 set_arch (wanted, set_arch_auto);
452 else if (wanted != target_architecture)
454 warning ("%s architecture file may be incompatible with %s target.",
455 wanted->printable_name,
456 target_architecture->printable_name);
461 /* Called if the user enters ``show architecture'' without an
465 show_architecture (char *args, int from_tty)
468 arch = TARGET_ARCHITECTURE->printable_name;
469 if (target_architecture_auto)
470 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
472 printf_filtered ("The target architecture is assumed to be %s\n", arch);
476 /* Called if the user enters ``set architecture'' with or without an
480 set_architecture (char *ignore_args, int from_tty, struct cmd_list_element *c)
482 if (strcmp (set_architecture_string, "auto") == 0)
484 target_architecture_auto = 1;
486 else if (GDB_MULTI_ARCH)
488 struct gdbarch_info info;
489 memset (&info, 0, sizeof info);
490 info.bfd_arch_info = bfd_scan_arch (set_architecture_string);
491 if (info.bfd_arch_info == NULL)
492 internal_error ("set_architecture: bfd_scan_arch failed");
493 if (gdbarch_update_p (info))
494 target_architecture_auto = 0;
496 printf_unfiltered ("Architecture `%s' not reconized.\n",
497 set_architecture_string);
501 const struct bfd_arch_info *arch
502 = bfd_scan_arch (set_architecture_string);
504 internal_error ("set_architecture: bfd_scan_arch failed");
505 set_arch (arch, set_arch_manual);
507 show_architecture (NULL, from_tty);
510 /* Called if the user enters ``info architecture'' without an argument. */
513 info_architecture (char *args, int from_tty)
515 printf_filtered ("Available architectures are:\n");
518 const char **arches = gdbarch_printable_names ();
520 for (arch = arches; *arch != NULL; arch++)
522 printf_filtered (" %s", *arch);
528 enum bfd_architecture a;
529 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
531 const struct bfd_arch_info *ap;
532 for (ap = bfd_lookup_arch (a, 0);
536 printf_filtered (" %s", ap->printable_name);
541 printf_filtered ("\n");
544 /* Set the dynamic target-system-dependent parameters (architecture,
545 byte-order) using information found in the BFD */
548 set_gdbarch_from_file (bfd *abfd)
552 struct gdbarch_info info;
553 memset (&info, 0, sizeof info);
555 if (! gdbarch_update_p (info))
556 error ("Architecture of file not reconized.\n");
560 set_architecture_from_file (abfd);
561 set_endian_from_file (abfd);
565 /* Initialize the current architecture. Update the ``set
566 architecture'' command so that it specifies a list of valid
569 #ifdef DEFAULT_BFD_ARCH
570 extern const bfd_arch_info_type DEFAULT_BFD_ARCH;
571 static const bfd_arch_info_type *default_bfd_arch = &DEFAULT_BFD_ARCH;
573 static const bfd_arch_info_type *default_bfd_arch;
576 #ifdef DEFAULT_BFD_VEC
577 extern const bfd_target DEFAULT_BFD_VEC;
578 static const bfd_target *default_bfd_vec = &DEFAULT_BFD_VEC;
580 static const bfd_target *default_bfd_vec;
584 initialize_current_architecture (void)
586 const char **arches = gdbarch_printable_names ();
588 /* determine a default architecture and byte order. */
589 struct gdbarch_info info;
590 memset (&info, 0, sizeof (info));
592 /* Find a default architecture. */
593 if (info.bfd_arch_info == NULL
594 && default_bfd_arch != NULL)
595 info.bfd_arch_info = default_bfd_arch;
596 if (info.bfd_arch_info == NULL)
598 /* Choose the architecture by taking the first one
600 const char *chosen = arches[0];
602 for (arch = arches; *arch != NULL; arch++)
604 if (strcmp (*arch, chosen) < 0)
608 internal_error ("initialize_current_architecture: No arch");
609 info.bfd_arch_info = bfd_scan_arch (chosen);
610 if (info.bfd_arch_info == NULL)
611 internal_error ("initialize_current_architecture: Arch not found");
614 /* take several guesses at a byte order. */
615 /* NB: can't use TARGET_BYTE_ORDER_DEFAULT as its definition is
617 if (info.byte_order == 0
618 && default_bfd_vec != NULL)
620 /* Extract BFD's default vector's byte order. */
621 switch (default_bfd_vec->byteorder)
624 info.byte_order = BIG_ENDIAN;
626 case BFD_ENDIAN_LITTLE:
627 info.byte_order = LITTLE_ENDIAN;
633 if (info.byte_order == 0)
635 /* look for ``*el-*'' in the target name. */
637 chp = strchr (target_name, '-');
639 && chp - 2 >= target_name
640 && strncmp (chp - 2, "el", 2) == 0)
641 info.byte_order = LITTLE_ENDIAN;
643 if (info.byte_order == 0)
645 /* Wire it to big-endian!!! */
646 info.byte_order = BIG_ENDIAN;
651 if (! gdbarch_update_p (info))
653 internal_error ("initialize_current_architecture: Selection of initial architecture failed");
657 /* Create the ``set architecture'' command appending ``auto'' to the
658 list of architectures. */
660 struct cmd_list_element *c;
661 /* Append ``auto''. */
663 for (nr = 0; arches[nr] != NULL; nr++);
664 arches = xrealloc (arches, sizeof (char*) * (nr + 2));
665 arches[nr + 0] = "auto";
666 arches[nr + 1] = NULL;
667 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
668 of ``const char *''. We just happen to know that the casts are
670 c = add_set_enum_cmd ("architecture", class_support,
671 arches, &set_architecture_string,
672 "Set architecture of target.",
674 c->function.sfunc = set_architecture;
675 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
676 /* Don't use set_from_show - need to print both auto/manual and
678 add_cmd ("architecture", class_support, show_architecture,
679 "Show the current target architecture", &showlist);
680 c = add_cmd ("architecture", class_support, info_architecture,
681 "List supported target architectures", &infolist);
682 deprecate_cmd (c, "set architecture");
689 extern initialize_file_ftype _initialize_gdbarch_utils;
692 _initialize_gdbarch_utils (void)
694 struct cmd_list_element *c;
695 c = add_set_enum_cmd ("endian", class_support,
696 endian_enum, &set_endian_string,
697 "Set endianness of target.",
699 c->function.sfunc = set_endian;
700 /* Don't use set_from_show - need to print both auto/manual and
702 add_cmd ("endian", class_support, show_endian,
703 "Show the current byte-order", &showlist);