1 /* Dynamic architecture support for GDB, the GNU debugger.
3 Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, 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"
36 #include "floatformat.h"
38 /* Implementation of extract return value that grubs around in the
41 legacy_extract_return_value (struct type
*type
, struct regcache
*regcache
,
44 char *registers
= deprecated_grub_regcache_for_registers (regcache
);
45 bfd_byte
*buf
= valbuf
;
46 DEPRECATED_EXTRACT_RETURN_VALUE (type
, registers
, buf
); /* OK */
49 /* Implementation of store return value that grubs the register cache.
50 Takes a local copy of the buffer to avoid const problems. */
52 legacy_store_return_value (struct type
*type
, struct regcache
*regcache
,
55 bfd_byte
*b
= alloca (TYPE_LENGTH (type
));
56 gdb_assert (regcache
== current_regcache
);
57 memcpy (b
, buf
, TYPE_LENGTH (type
));
58 DEPRECATED_STORE_RETURN_VALUE (type
, b
);
63 always_use_struct_convention (int gcc_p
, struct type
*value_type
)
70 legacy_register_sim_regno (int regnum
)
72 /* Only makes sense to supply raw registers. */
73 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
);
74 /* NOTE: cagney/2002-05-13: The old code did it this way and it is
75 suspected that some GDB/SIM combinations may rely on this
76 behavour. The default should be one2one_register_sim_regno
78 if (REGISTER_NAME (regnum
) != NULL
79 && REGISTER_NAME (regnum
)[0] != '\0')
82 return LEGACY_SIM_REGNO_IGNORE
;
86 generic_frameless_function_invocation_not (struct frame_info
*fi
)
92 generic_return_value_on_stack_not (struct type
*type
)
98 generic_skip_trampoline_code (CORE_ADDR pc
)
104 generic_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
110 generic_in_solib_return_trampoline (CORE_ADDR pc
, char *name
)
116 generic_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
121 #if defined (CALL_DUMMY)
122 LONGEST legacy_call_dummy_words
[] = CALL_DUMMY
;
124 LONGEST legacy_call_dummy_words
[1];
126 int legacy_sizeof_call_dummy_words
= sizeof (legacy_call_dummy_words
);
129 generic_remote_translate_xfer_address (struct gdbarch
*gdbarch
,
130 struct regcache
*regcache
,
131 CORE_ADDR gdb_addr
, int gdb_len
,
132 CORE_ADDR
* rem_addr
, int *rem_len
)
134 *rem_addr
= gdb_addr
;
139 generic_prologue_frameless_p (CORE_ADDR ip
)
141 return ip
== SKIP_PROLOGUE (ip
);
144 /* Helper functions for INNER_THAN */
147 core_addr_lessthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
153 core_addr_greaterthan (CORE_ADDR lhs
, CORE_ADDR rhs
)
159 /* Helper functions for TARGET_{FLOAT,DOUBLE}_FORMAT */
161 const struct floatformat
*
162 default_float_format (struct gdbarch
*gdbarch
)
164 int byte_order
= gdbarch_byte_order (gdbarch
);
168 return &floatformat_ieee_single_big
;
169 case BFD_ENDIAN_LITTLE
:
170 return &floatformat_ieee_single_little
;
172 internal_error (__FILE__
, __LINE__
,
173 "default_float_format: bad byte order");
178 const struct floatformat
*
179 default_double_format (struct gdbarch
*gdbarch
)
181 int byte_order
= gdbarch_byte_order (gdbarch
);
185 return &floatformat_ieee_double_big
;
186 case BFD_ENDIAN_LITTLE
:
187 return &floatformat_ieee_double_little
;
189 internal_error (__FILE__
, __LINE__
,
190 "default_double_format: bad byte order");
194 /* Misc helper functions for targets. */
197 deprecated_register_convertible_not (int num
)
204 core_addr_identity (CORE_ADDR addr
)
210 convert_from_func_ptr_addr_identity (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
211 struct target_ops
*targ
)
217 no_op_reg_to_regnum (int reg
)
223 deprecated_init_frame_pc_default (int fromleaf
, struct frame_info
*prev
)
225 if (fromleaf
&& DEPRECATED_SAVED_PC_AFTER_CALL_P ())
226 return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev
));
227 else if (get_next_frame (prev
) != NULL
)
228 return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev
));
234 default_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
240 default_coff_make_msymbol_special (int val
, struct minimal_symbol
*msym
)
246 cannot_register_not (int regnum
)
251 /* Legacy version of target_virtual_frame_pointer(). Assumes that
252 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
256 legacy_virtual_frame_pointer (CORE_ADDR pc
,
258 LONGEST
*frame_offset
)
260 /* FIXME: cagney/2002-09-13: This code is used when identifying the
261 frame pointer of the current PC. It is assuming that a single
262 register and an offset can determine this. I think it should
263 instead generate a byte code expression as that would work better
264 with things like Dwarf2's CFI. */
265 if (DEPRECATED_FP_REGNUM
>= 0 && DEPRECATED_FP_REGNUM
< NUM_REGS
)
266 *frame_regnum
= DEPRECATED_FP_REGNUM
;
267 else if (SP_REGNUM
>= 0 && SP_REGNUM
< NUM_REGS
)
268 *frame_regnum
= SP_REGNUM
;
270 /* Should this be an internal error? I guess so, it is reflecting
271 an architectural limitation in the current design. */
272 internal_error (__FILE__
, __LINE__
, "No virtual frame pointer available");
276 /* Assume the world is sane, every register's virtual and real size
280 generic_register_size (int regnum
)
282 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
283 if (gdbarch_register_type_p (current_gdbarch
))
284 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch
, regnum
));
286 /* FIXME: cagney/2003-03-01: Once all architectures implement
287 gdbarch_register_type(), this entire function can go away. It
288 is made obsolete by register_size(). */
289 return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum
)); /* OK */
292 /* Assume all registers are adjacent. */
295 generic_register_byte (int regnum
)
299 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
301 for (i
= 0; i
< regnum
; i
++)
303 byte
+= generic_register_size (i
);
310 legacy_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
312 #if !defined (IN_SIGTRAMP)
313 if (SIGTRAMP_START_P ())
314 return (pc
) >= SIGTRAMP_START (pc
) && (pc
) < SIGTRAMP_END (pc
);
316 return name
&& strcmp ("_sigtramp", name
) == 0;
318 return IN_SIGTRAMP (pc
, name
);
323 legacy_convert_register_p (int regnum
, struct type
*type
)
325 return DEPRECATED_REGISTER_CONVERTIBLE (regnum
);
329 legacy_register_to_value (struct frame_info
*frame
, int regnum
,
330 struct type
*type
, void *to
)
332 char from
[MAX_REGISTER_SIZE
];
333 get_frame_register (frame
, regnum
, from
);
334 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
);
338 legacy_value_to_register (struct frame_info
*frame
, int regnum
,
339 struct type
*type
, const void *tmp
)
341 char to
[MAX_REGISTER_SIZE
];
342 char *from
= alloca (TYPE_LENGTH (type
));
343 memcpy (from
, from
, TYPE_LENGTH (type
));
344 DEPRECATED_REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
);
345 put_frame_register (frame
, regnum
, to
);
349 default_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
351 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
352 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, type
))
354 CHECK_TYPEDEF (type
);
356 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
357 || TYPE_CODE (type
) == TYPE_CODE_UNION
358 || TYPE_CODE (type
) == TYPE_CODE_SET
359 || TYPE_CODE (type
) == TYPE_CODE_BITSTRING
);
366 /* Functions to manipulate the endianness of the target. */
368 /* ``target_byte_order'' is only used when non- multi-arch.
369 Multi-arch targets obtain the current byte order using the
370 TARGET_BYTE_ORDER gdbarch method.
372 The choice of initial value is entirely arbitrary. During startup,
373 the function initialize_current_architecture() updates this value
374 based on default byte-order information extracted from BFD. */
375 int target_byte_order
= BFD_ENDIAN_BIG
;
376 int target_byte_order_auto
= 1;
378 static const char endian_big
[] = "big";
379 static const char endian_little
[] = "little";
380 static const char endian_auto
[] = "auto";
381 static const char *endian_enum
[] =
388 static const char *set_endian_string
;
390 /* Called by ``show endian''. */
393 show_endian (char *args
, int from_tty
)
395 if (TARGET_BYTE_ORDER_AUTO
)
396 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
397 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
399 printf_unfiltered ("The target is assumed to be %s endian\n",
400 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
404 set_endian (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
406 if (set_endian_string
== endian_auto
)
408 target_byte_order_auto
= 1;
410 else if (set_endian_string
== endian_little
)
412 struct gdbarch_info info
;
413 target_byte_order_auto
= 0;
414 gdbarch_info_init (&info
);
415 info
.byte_order
= BFD_ENDIAN_LITTLE
;
416 if (! gdbarch_update_p (info
))
417 printf_unfiltered ("Little endian target not supported by GDB\n");
419 else if (set_endian_string
== endian_big
)
421 struct gdbarch_info info
;
422 target_byte_order_auto
= 0;
423 gdbarch_info_init (&info
);
424 info
.byte_order
= BFD_ENDIAN_BIG
;
425 if (! gdbarch_update_p (info
))
426 printf_unfiltered ("Big endian target not supported by GDB\n");
429 internal_error (__FILE__
, __LINE__
,
430 "set_endian: bad value");
431 show_endian (NULL
, from_tty
);
434 /* Functions to manipulate the architecture of the target */
436 enum set_arch
{ set_arch_auto
, set_arch_manual
};
438 int target_architecture_auto
= 1;
440 const char *set_architecture_string
;
442 /* Called if the user enters ``show architecture'' without an
446 show_architecture (char *args
, int from_tty
)
449 arch
= TARGET_ARCHITECTURE
->printable_name
;
450 if (target_architecture_auto
)
451 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
453 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
457 /* Called if the user enters ``set architecture'' with or without an
461 set_architecture (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
463 if (strcmp (set_architecture_string
, "auto") == 0)
465 target_architecture_auto
= 1;
469 struct gdbarch_info info
;
470 gdbarch_info_init (&info
);
471 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
472 if (info
.bfd_arch_info
== NULL
)
473 internal_error (__FILE__
, __LINE__
,
474 "set_architecture: bfd_scan_arch failed");
475 if (gdbarch_update_p (info
))
476 target_architecture_auto
= 0;
478 printf_unfiltered ("Architecture `%s' not recognized.\n",
479 set_architecture_string
);
481 show_architecture (NULL
, from_tty
);
484 /* FIXME: kettenis/20031124: Of the functions that follow, only
485 gdbarch_from_bfd is supposed to survive. The others will
486 dissappear since in the future GDB will (hopefully) be truly
487 multi-arch. However, for now we're still stuck with the concept of
488 a single active architecture. */
490 /* Make GDBARCH the currently selected architecture. */
493 deprecated_select_gdbarch_hack (struct gdbarch
*gdbarch
)
495 struct gdbarch_info info
;
497 /* FIXME: kettenis/20031024: The only way to select a specific
498 architecture is to clone its `struct gdbarch_info', and update
499 according to that copy. This is gross, but significant work will
500 need to be done before we can take a more sane approach. */
501 gdbarch_info_init (&info
);
502 info
.bfd_arch_info
= gdbarch_bfd_arch_info (gdbarch
);
503 info
.byte_order
= gdbarch_byte_order (gdbarch
);
504 info
.osabi
= gdbarch_osabi (gdbarch
);
505 gdbarch_update_p (info
);
506 gdb_assert (gdbarch
== current_gdbarch
);
509 /* Return the architecture for ABFD. If no suitable architecture
510 could be find, return NULL. */
513 gdbarch_from_bfd (bfd
*abfd
)
515 struct gdbarch
*old_gdbarch
= current_gdbarch
;
516 struct gdbarch
*new_gdbarch
;
517 struct gdbarch_info info
;
519 /* FIXME: kettenis/20031024: The only way to find the architecture
520 for a certain BFD is by doing an architecture update. This
521 activates the architecture, so we need to reactivate the old
522 architecture. This is gross, but significant work will need to
523 be done before we can take a more sane approach. */
524 gdbarch_info_init (&info
);
526 if (! gdbarch_update_p (info
))
529 new_gdbarch
= current_gdbarch
;
530 deprecated_select_gdbarch_hack (old_gdbarch
);
534 /* Set the dynamic target-system-dependent parameters (architecture,
535 byte-order) using information found in the BFD */
538 set_gdbarch_from_file (bfd
*abfd
)
540 struct gdbarch
*gdbarch
;
542 gdbarch
= gdbarch_from_bfd (abfd
);
544 error ("Architecture of file not recognized.\n");
545 deprecated_select_gdbarch_hack (gdbarch
);
548 /* Initialize the current architecture. Update the ``set
549 architecture'' command so that it specifies a list of valid
552 #ifdef DEFAULT_BFD_ARCH
553 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
554 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
556 static const bfd_arch_info_type
*default_bfd_arch
;
559 #ifdef DEFAULT_BFD_VEC
560 extern const bfd_target DEFAULT_BFD_VEC
;
561 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
563 static const bfd_target
*default_bfd_vec
;
567 initialize_current_architecture (void)
569 const char **arches
= gdbarch_printable_names ();
571 /* determine a default architecture and byte order. */
572 struct gdbarch_info info
;
573 gdbarch_info_init (&info
);
575 /* Find a default architecture. */
576 if (info
.bfd_arch_info
== NULL
577 && default_bfd_arch
!= NULL
)
578 info
.bfd_arch_info
= default_bfd_arch
;
579 if (info
.bfd_arch_info
== NULL
)
581 /* Choose the architecture by taking the first one
583 const char *chosen
= arches
[0];
585 for (arch
= arches
; *arch
!= NULL
; arch
++)
587 if (strcmp (*arch
, chosen
) < 0)
591 internal_error (__FILE__
, __LINE__
,
592 "initialize_current_architecture: No arch");
593 info
.bfd_arch_info
= bfd_scan_arch (chosen
);
594 if (info
.bfd_arch_info
== NULL
)
595 internal_error (__FILE__
, __LINE__
,
596 "initialize_current_architecture: Arch not found");
599 /* Take several guesses at a byte order. */
600 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
601 && default_bfd_vec
!= NULL
)
603 /* Extract BFD's default vector's byte order. */
604 switch (default_bfd_vec
->byteorder
)
607 info
.byte_order
= BFD_ENDIAN_BIG
;
609 case BFD_ENDIAN_LITTLE
:
610 info
.byte_order
= BFD_ENDIAN_LITTLE
;
616 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
618 /* look for ``*el-*'' in the target name. */
620 chp
= strchr (target_name
, '-');
622 && chp
- 2 >= target_name
623 && strncmp (chp
- 2, "el", 2) == 0)
624 info
.byte_order
= BFD_ENDIAN_LITTLE
;
626 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
628 /* Wire it to big-endian!!! */
629 info
.byte_order
= BFD_ENDIAN_BIG
;
632 if (! gdbarch_update_p (info
))
633 internal_error (__FILE__
, __LINE__
,
634 "initialize_current_architecture: Selection of initial architecture failed");
636 /* Create the ``set architecture'' command appending ``auto'' to the
637 list of architectures. */
639 struct cmd_list_element
*c
;
640 /* Append ``auto''. */
642 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
643 arches
= xrealloc (arches
, sizeof (char*) * (nr
+ 2));
644 arches
[nr
+ 0] = "auto";
645 arches
[nr
+ 1] = NULL
;
646 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
647 of ``const char *''. We just happen to know that the casts are
649 c
= add_set_enum_cmd ("architecture", class_support
,
650 arches
, &set_architecture_string
,
651 "Set architecture of target.",
653 set_cmd_sfunc (c
, set_architecture
);
654 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
655 /* Don't use set_from_show - need to print both auto/manual and
657 add_cmd ("architecture", class_support
, show_architecture
,
658 "Show the current target architecture", &showlist
);
663 /* Initialize a gdbarch info to values that will be automatically
664 overridden. Note: Originally, this ``struct info'' was initialized
665 using memset(0). Unfortunately, that ran into problems, namely
666 BFD_ENDIAN_BIG is zero. An explicit initialization function that
667 can explicitly set each field to a well defined value is used. */
670 gdbarch_info_init (struct gdbarch_info
*info
)
672 memset (info
, 0, sizeof (struct gdbarch_info
));
673 info
->byte_order
= BFD_ENDIAN_UNKNOWN
;
674 info
->osabi
= GDB_OSABI_UNINITIALIZED
;
679 extern initialize_file_ftype _initialize_gdbarch_utils
; /* -Wmissing-prototypes */
682 _initialize_gdbarch_utils (void)
684 struct cmd_list_element
*c
;
685 c
= add_set_enum_cmd ("endian", class_support
,
686 endian_enum
, &set_endian_string
,
687 "Set endianness of target.",
689 set_cmd_sfunc (c
, set_endian
);
690 /* Don't use set_from_show - need to print both auto/manual and
692 add_cmd ("endian", class_support
, show_endian
,
693 "Show the current byte-order", &showlist
);