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
)
231 default_convert_from_func_ptr_addr (CORE_ADDR addr
)
237 no_op_reg_to_regnum (int reg
)
242 /* Functions to manipulate the endianness of the target. */
244 #ifdef TARGET_BYTE_ORDER_SELECTABLE
245 /* compat - Catch old targets that expect a selectable byte-order to
246 default to BIG_ENDIAN */
247 #ifndef TARGET_BYTE_ORDER_DEFAULT
248 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
251 #if !TARGET_BYTE_ORDER_SELECTABLE_P
252 #ifndef TARGET_BYTE_ORDER_DEFAULT
253 /* compat - Catch old non byte-order selectable targets that do not
254 define TARGET_BYTE_ORDER_DEFAULT and instead expect
255 TARGET_BYTE_ORDER to be used as the default. For targets that
256 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
257 below will get a strange compiler warning. */
258 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
261 #ifndef TARGET_BYTE_ORDER_DEFAULT
262 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
264 /* ``target_byte_order'' is only used when non- multi-arch.
265 Multi-arch targets obtain the current byte order using
266 TARGET_BYTE_ORDER which is controlled by gdbarch.*. */
267 int target_byte_order
= TARGET_BYTE_ORDER_DEFAULT
;
268 int target_byte_order_auto
= 1;
270 static const char endian_big
[] = "big";
271 static const char endian_little
[] = "little";
272 static const char endian_auto
[] = "auto";
273 static const char *endian_enum
[] =
280 static const char *set_endian_string
;
282 /* Called by ``show endian''. */
285 show_endian (char *args
, int from_tty
)
287 if (TARGET_BYTE_ORDER_AUTO
)
288 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
289 (TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little"));
291 printf_unfiltered ("The target is assumed to be %s endian\n",
292 (TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little"));
296 set_endian (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
298 if (!TARGET_BYTE_ORDER_SELECTABLE_P
)
300 printf_unfiltered ("Byte order is not selectable.");
302 else if (set_endian_string
== endian_auto
)
304 target_byte_order_auto
= 1;
306 else if (set_endian_string
== endian_little
)
308 target_byte_order_auto
= 0;
311 struct gdbarch_info info
;
312 memset (&info
, 0, sizeof info
);
313 info
.byte_order
= LITTLE_ENDIAN
;
314 if (! gdbarch_update_p (info
))
316 printf_unfiltered ("Little endian target not supported by GDB\n");
321 target_byte_order
= LITTLE_ENDIAN
;
324 else if (set_endian_string
== endian_big
)
326 target_byte_order_auto
= 0;
329 struct gdbarch_info info
;
330 memset (&info
, 0, sizeof info
);
331 info
.byte_order
= BIG_ENDIAN
;
332 if (! gdbarch_update_p (info
))
334 printf_unfiltered ("Big endian target not supported by GDB\n");
339 target_byte_order
= BIG_ENDIAN
;
343 internal_error ("set_endian: bad value");
344 show_endian (NULL
, from_tty
);
347 /* Set the endianness from a BFD. */
350 set_endian_from_file (bfd
*abfd
)
353 internal_error ("set_endian_from_file: not for multi-arch");
354 if (TARGET_BYTE_ORDER_SELECTABLE_P
)
358 if (bfd_big_endian (abfd
))
361 want
= LITTLE_ENDIAN
;
362 if (TARGET_BYTE_ORDER_AUTO
)
363 target_byte_order
= want
;
364 else if (TARGET_BYTE_ORDER
!= want
)
365 warning ("%s endian file does not match %s endian target.",
366 want
== BIG_ENDIAN
? "big" : "little",
367 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
371 if (bfd_big_endian (abfd
)
372 ? TARGET_BYTE_ORDER
!= BIG_ENDIAN
373 : TARGET_BYTE_ORDER
== BIG_ENDIAN
)
374 warning ("%s endian file does not match %s endian target.",
375 bfd_big_endian (abfd
) ? "big" : "little",
376 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
381 /* Functions to manipulate the architecture of the target */
383 enum set_arch
{ set_arch_auto
, set_arch_manual
};
385 int target_architecture_auto
= 1;
387 const char *set_architecture_string
;
389 /* Old way of changing the current architecture. */
391 extern const struct bfd_arch_info bfd_default_arch_struct
;
392 const struct bfd_arch_info
*target_architecture
= &bfd_default_arch_struct
;
393 int (*target_architecture_hook
) (const struct bfd_arch_info
*ap
);
396 arch_ok (const struct bfd_arch_info
*arch
)
399 internal_error ("arch_ok: not multi-arched");
400 /* Should be performing the more basic check that the binary is
401 compatible with GDB. */
402 /* Check with the target that the architecture is valid. */
403 return (target_architecture_hook
== NULL
404 || target_architecture_hook (arch
));
408 set_arch (const struct bfd_arch_info
*arch
,
412 internal_error ("set_arch: not multi-arched");
417 warning ("Target may not support %s architecture",
418 arch
->printable_name
);
419 target_architecture
= arch
;
421 case set_arch_manual
:
424 printf_unfiltered ("Target does not support `%s' architecture.\n",
425 arch
->printable_name
);
429 target_architecture_auto
= 0;
430 target_architecture
= arch
;
435 gdbarch_dump (current_gdbarch
, gdb_stdlog
);
438 /* Set the architecture from arch/machine (deprecated) */
441 set_architecture_from_arch_mach (enum bfd_architecture arch
,
444 const struct bfd_arch_info
*wanted
= bfd_lookup_arch (arch
, mach
);
446 internal_error ("set_architecture_from_arch_mach: not multi-arched");
448 set_arch (wanted
, set_arch_manual
);
450 internal_error ("gdbarch: hardwired architecture/machine not recognized");
453 /* Set the architecture from a BFD (deprecated) */
456 set_architecture_from_file (bfd
*abfd
)
458 const struct bfd_arch_info
*wanted
= bfd_get_arch_info (abfd
);
460 internal_error ("set_architecture_from_file: not multi-arched");
461 if (target_architecture_auto
)
463 set_arch (wanted
, set_arch_auto
);
465 else if (wanted
!= target_architecture
)
467 warning ("%s architecture file may be incompatible with %s target.",
468 wanted
->printable_name
,
469 target_architecture
->printable_name
);
474 /* Called if the user enters ``show architecture'' without an
478 show_architecture (char *args
, int from_tty
)
481 arch
= TARGET_ARCHITECTURE
->printable_name
;
482 if (target_architecture_auto
)
483 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
485 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
489 /* Called if the user enters ``set architecture'' with or without an
493 set_architecture (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
495 if (strcmp (set_architecture_string
, "auto") == 0)
497 target_architecture_auto
= 1;
499 else if (GDB_MULTI_ARCH
)
501 struct gdbarch_info info
;
502 memset (&info
, 0, sizeof info
);
503 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
504 if (info
.bfd_arch_info
== NULL
)
505 internal_error ("set_architecture: bfd_scan_arch failed");
506 if (gdbarch_update_p (info
))
507 target_architecture_auto
= 0;
509 printf_unfiltered ("Architecture `%s' not recognized.\n",
510 set_architecture_string
);
514 const struct bfd_arch_info
*arch
515 = bfd_scan_arch (set_architecture_string
);
517 internal_error ("set_architecture: bfd_scan_arch failed");
518 set_arch (arch
, set_arch_manual
);
520 show_architecture (NULL
, from_tty
);
523 /* Called if the user enters ``info architecture'' without an argument. */
526 info_architecture (char *args
, int from_tty
)
528 printf_filtered ("Available architectures are:\n");
531 const char **arches
= gdbarch_printable_names ();
533 for (arch
= arches
; *arch
!= NULL
; arch
++)
535 printf_filtered (" %s", *arch
);
541 enum bfd_architecture a
;
542 for (a
= bfd_arch_obscure
+ 1; a
< bfd_arch_last
; a
++)
544 const struct bfd_arch_info
*ap
;
545 for (ap
= bfd_lookup_arch (a
, 0);
549 printf_filtered (" %s", ap
->printable_name
);
554 printf_filtered ("\n");
557 /* Set the dynamic target-system-dependent parameters (architecture,
558 byte-order) using information found in the BFD */
561 set_gdbarch_from_file (bfd
*abfd
)
565 struct gdbarch_info info
;
566 memset (&info
, 0, sizeof info
);
568 if (! gdbarch_update_p (info
))
569 error ("Architecture of file not recognized.\n");
573 set_architecture_from_file (abfd
);
574 set_endian_from_file (abfd
);
578 /* Initialize the current architecture. Update the ``set
579 architecture'' command so that it specifies a list of valid
582 #ifdef DEFAULT_BFD_ARCH
583 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
584 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
586 static const bfd_arch_info_type
*default_bfd_arch
;
589 #ifdef DEFAULT_BFD_VEC
590 extern const bfd_target DEFAULT_BFD_VEC
;
591 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
593 static const bfd_target
*default_bfd_vec
;
597 initialize_current_architecture (void)
599 const char **arches
= gdbarch_printable_names ();
601 /* determine a default architecture and byte order. */
602 struct gdbarch_info info
;
603 memset (&info
, 0, sizeof (info
));
605 /* Find a default architecture. */
606 if (info
.bfd_arch_info
== NULL
607 && default_bfd_arch
!= NULL
)
608 info
.bfd_arch_info
= default_bfd_arch
;
609 if (info
.bfd_arch_info
== NULL
)
611 /* Choose the architecture by taking the first one
613 const char *chosen
= arches
[0];
615 for (arch
= arches
; *arch
!= NULL
; arch
++)
617 if (strcmp (*arch
, chosen
) < 0)
621 internal_error ("initialize_current_architecture: No arch");
622 info
.bfd_arch_info
= bfd_scan_arch (chosen
);
623 if (info
.bfd_arch_info
== NULL
)
624 internal_error ("initialize_current_architecture: Arch not found");
627 /* take several guesses at a byte order. */
628 /* NB: can't use TARGET_BYTE_ORDER_DEFAULT as its definition is
630 if (info
.byte_order
== 0
631 && default_bfd_vec
!= NULL
)
633 /* Extract BFD's default vector's byte order. */
634 switch (default_bfd_vec
->byteorder
)
637 info
.byte_order
= BIG_ENDIAN
;
639 case BFD_ENDIAN_LITTLE
:
640 info
.byte_order
= LITTLE_ENDIAN
;
646 if (info
.byte_order
== 0)
648 /* look for ``*el-*'' in the target name. */
650 chp
= strchr (target_name
, '-');
652 && chp
- 2 >= target_name
653 && strncmp (chp
- 2, "el", 2) == 0)
654 info
.byte_order
= LITTLE_ENDIAN
;
656 if (info
.byte_order
== 0)
658 /* Wire it to big-endian!!! */
659 info
.byte_order
= BIG_ENDIAN
;
664 if (! gdbarch_update_p (info
))
666 internal_error ("initialize_current_architecture: Selection of initial architecture failed");
670 /* Create the ``set architecture'' command appending ``auto'' to the
671 list of architectures. */
673 struct cmd_list_element
*c
;
674 /* Append ``auto''. */
676 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
677 arches
= xrealloc (arches
, sizeof (char*) * (nr
+ 2));
678 arches
[nr
+ 0] = "auto";
679 arches
[nr
+ 1] = NULL
;
680 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
681 of ``const char *''. We just happen to know that the casts are
683 c
= add_set_enum_cmd ("architecture", class_support
,
684 arches
, &set_architecture_string
,
685 "Set architecture of target.",
687 c
->function
.sfunc
= set_architecture
;
688 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
689 /* Don't use set_from_show - need to print both auto/manual and
691 add_cmd ("architecture", class_support
, show_architecture
,
692 "Show the current target architecture", &showlist
);
693 c
= add_cmd ("architecture", class_support
, info_architecture
,
694 "List supported target architectures", &infolist
);
695 deprecate_cmd (c
, "set architecture");
702 extern initialize_file_ftype _initialize_gdbarch_utils
;
705 _initialize_gdbarch_utils (void)
707 struct cmd_list_element
*c
;
708 c
= add_set_enum_cmd ("endian", class_support
,
709 endian_enum
, &set_endian_string
,
710 "Set endianness of target.",
712 c
->function
.sfunc
= set_endian
;
713 /* Don't use set_from_show - need to print both auto/manual and
715 add_cmd ("endian", class_support
, show_endian
,
716 "Show the current byte-order", &showlist
);