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
)
203 /* Under some ABI's that specify the `struct convention' for returning
204 structures by value, by the time we've returned from the function,
205 the return value is sitting there in the caller's buffer, but GDB
206 has no way to find the address of that buffer.
208 On such architectures, use this function as your
209 extract_struct_value_address method. When asked to a struct
210 returned by value in this fashion, GDB will print a nice error
211 message, instead of garbage. */
213 generic_cannot_extract_struct_value_address (char *dummy
)
219 core_addr_identity (CORE_ADDR addr
)
225 no_op_reg_to_regnum (int reg
)
231 deprecated_init_frame_pc_default (int fromleaf
, struct frame_info
*prev
)
233 if (fromleaf
&& DEPRECATED_SAVED_PC_AFTER_CALL_P ())
234 return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev
));
235 else if (get_next_frame (prev
) != NULL
)
236 return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev
));
242 default_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
248 default_coff_make_msymbol_special (int val
, struct minimal_symbol
*msym
)
254 cannot_register_not (int regnum
)
259 /* Legacy version of target_virtual_frame_pointer(). Assumes that
260 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
264 legacy_virtual_frame_pointer (CORE_ADDR pc
,
266 LONGEST
*frame_offset
)
268 /* FIXME: cagney/2002-09-13: This code is used when identifying the
269 frame pointer of the current PC. It is assuming that a single
270 register and an offset can determine this. I think it should
271 instead generate a byte code expression as that would work better
272 with things like Dwarf2's CFI. */
273 if (DEPRECATED_FP_REGNUM
>= 0 && DEPRECATED_FP_REGNUM
< NUM_REGS
)
274 *frame_regnum
= DEPRECATED_FP_REGNUM
;
275 else if (SP_REGNUM
>= 0 && SP_REGNUM
< NUM_REGS
)
276 *frame_regnum
= SP_REGNUM
;
278 /* Should this be an internal error? I guess so, it is reflecting
279 an architectural limitation in the current design. */
280 internal_error (__FILE__
, __LINE__
, "No virtual frame pointer available");
284 /* Assume the world is sane, every register's virtual and real size
288 generic_register_size (int regnum
)
290 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
291 if (gdbarch_register_type_p (current_gdbarch
))
292 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch
, regnum
));
294 /* FIXME: cagney/2003-03-01: Once all architectures implement
295 gdbarch_register_type(), this entire function can go away. It
296 is made obsolete by register_size(). */
297 return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum
)); /* OK */
300 /* Assume all registers are adjacent. */
303 generic_register_byte (int regnum
)
307 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
309 for (i
= 0; i
< regnum
; i
++)
311 byte
+= generic_register_size (i
);
318 legacy_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
320 #if !defined (IN_SIGTRAMP)
321 if (SIGTRAMP_START_P ())
322 return (pc
) >= SIGTRAMP_START (pc
) && (pc
) < SIGTRAMP_END (pc
);
324 return name
&& strcmp ("_sigtramp", name
) == 0;
326 return IN_SIGTRAMP (pc
, name
);
331 legacy_convert_register_p (int regnum
, struct type
*type
)
333 return DEPRECATED_REGISTER_CONVERTIBLE (regnum
);
337 legacy_register_to_value (struct frame_info
*frame
, int regnum
,
338 struct type
*type
, void *to
)
340 char from
[MAX_REGISTER_SIZE
];
341 frame_read_register (frame
, regnum
, from
);
342 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
);
346 legacy_value_to_register (struct frame_info
*frame
, int regnum
,
347 struct type
*type
, const void *tmp
)
349 char to
[MAX_REGISTER_SIZE
];
350 char *from
= alloca (TYPE_LENGTH (type
));
351 memcpy (from
, from
, TYPE_LENGTH (type
));
352 DEPRECATED_REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
);
353 put_frame_register (frame
, regnum
, to
);
357 default_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
359 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
360 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, type
))
362 CHECK_TYPEDEF (type
);
364 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
365 || TYPE_CODE (type
) == TYPE_CODE_UNION
366 || TYPE_CODE (type
) == TYPE_CODE_SET
367 || TYPE_CODE (type
) == TYPE_CODE_BITSTRING
);
374 /* Functions to manipulate the endianness of the target. */
376 /* ``target_byte_order'' is only used when non- multi-arch.
377 Multi-arch targets obtain the current byte order using the
378 TARGET_BYTE_ORDER gdbarch method.
380 The choice of initial value is entirely arbitrary. During startup,
381 the function initialize_current_architecture() updates this value
382 based on default byte-order information extracted from BFD. */
383 int target_byte_order
= BFD_ENDIAN_BIG
;
384 int target_byte_order_auto
= 1;
386 static const char endian_big
[] = "big";
387 static const char endian_little
[] = "little";
388 static const char endian_auto
[] = "auto";
389 static const char *endian_enum
[] =
396 static const char *set_endian_string
;
398 /* Called by ``show endian''. */
401 show_endian (char *args
, int from_tty
)
403 if (TARGET_BYTE_ORDER_AUTO
)
404 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
405 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
407 printf_unfiltered ("The target is assumed to be %s endian\n",
408 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
412 set_endian (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
414 if (set_endian_string
== endian_auto
)
416 target_byte_order_auto
= 1;
418 else if (set_endian_string
== endian_little
)
420 struct gdbarch_info info
;
421 target_byte_order_auto
= 0;
422 gdbarch_info_init (&info
);
423 info
.byte_order
= BFD_ENDIAN_LITTLE
;
424 if (! gdbarch_update_p (info
))
425 printf_unfiltered ("Little endian target not supported by GDB\n");
427 else if (set_endian_string
== endian_big
)
429 struct gdbarch_info info
;
430 target_byte_order_auto
= 0;
431 gdbarch_info_init (&info
);
432 info
.byte_order
= BFD_ENDIAN_BIG
;
433 if (! gdbarch_update_p (info
))
434 printf_unfiltered ("Big endian target not supported by GDB\n");
437 internal_error (__FILE__
, __LINE__
,
438 "set_endian: bad value");
439 show_endian (NULL
, from_tty
);
442 /* Functions to manipulate the architecture of the target */
444 enum set_arch
{ set_arch_auto
, set_arch_manual
};
446 int target_architecture_auto
= 1;
448 const char *set_architecture_string
;
450 /* Called if the user enters ``show architecture'' without an
454 show_architecture (char *args
, int from_tty
)
457 arch
= TARGET_ARCHITECTURE
->printable_name
;
458 if (target_architecture_auto
)
459 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
461 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
465 /* Called if the user enters ``set architecture'' with or without an
469 set_architecture (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
471 if (strcmp (set_architecture_string
, "auto") == 0)
473 target_architecture_auto
= 1;
477 struct gdbarch_info info
;
478 gdbarch_info_init (&info
);
479 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
480 if (info
.bfd_arch_info
== NULL
)
481 internal_error (__FILE__
, __LINE__
,
482 "set_architecture: bfd_scan_arch failed");
483 if (gdbarch_update_p (info
))
484 target_architecture_auto
= 0;
486 printf_unfiltered ("Architecture `%s' not recognized.\n",
487 set_architecture_string
);
489 show_architecture (NULL
, from_tty
);
492 /* Set the dynamic target-system-dependent parameters (architecture,
493 byte-order) using information found in the BFD */
496 set_gdbarch_from_file (bfd
*abfd
)
498 struct gdbarch_info info
;
499 gdbarch_info_init (&info
);
501 if (! gdbarch_update_p (info
))
502 error ("Architecture of file not recognized.\n");
505 /* Initialize the current architecture. Update the ``set
506 architecture'' command so that it specifies a list of valid
509 #ifdef DEFAULT_BFD_ARCH
510 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
511 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
513 static const bfd_arch_info_type
*default_bfd_arch
;
516 #ifdef DEFAULT_BFD_VEC
517 extern const bfd_target DEFAULT_BFD_VEC
;
518 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
520 static const bfd_target
*default_bfd_vec
;
524 initialize_current_architecture (void)
526 const char **arches
= gdbarch_printable_names ();
528 /* determine a default architecture and byte order. */
529 struct gdbarch_info info
;
530 gdbarch_info_init (&info
);
532 /* Find a default architecture. */
533 if (info
.bfd_arch_info
== NULL
534 && default_bfd_arch
!= NULL
)
535 info
.bfd_arch_info
= default_bfd_arch
;
536 if (info
.bfd_arch_info
== NULL
)
538 /* Choose the architecture by taking the first one
540 const char *chosen
= arches
[0];
542 for (arch
= arches
; *arch
!= NULL
; arch
++)
544 if (strcmp (*arch
, chosen
) < 0)
548 internal_error (__FILE__
, __LINE__
,
549 "initialize_current_architecture: No arch");
550 info
.bfd_arch_info
= bfd_scan_arch (chosen
);
551 if (info
.bfd_arch_info
== NULL
)
552 internal_error (__FILE__
, __LINE__
,
553 "initialize_current_architecture: Arch not found");
556 /* Take several guesses at a byte order. */
557 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
558 && default_bfd_vec
!= NULL
)
560 /* Extract BFD's default vector's byte order. */
561 switch (default_bfd_vec
->byteorder
)
564 info
.byte_order
= BFD_ENDIAN_BIG
;
566 case BFD_ENDIAN_LITTLE
:
567 info
.byte_order
= BFD_ENDIAN_LITTLE
;
573 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
575 /* look for ``*el-*'' in the target name. */
577 chp
= strchr (target_name
, '-');
579 && chp
- 2 >= target_name
580 && strncmp (chp
- 2, "el", 2) == 0)
581 info
.byte_order
= BFD_ENDIAN_LITTLE
;
583 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
585 /* Wire it to big-endian!!! */
586 info
.byte_order
= BFD_ENDIAN_BIG
;
589 if (! gdbarch_update_p (info
))
590 internal_error (__FILE__
, __LINE__
,
591 "initialize_current_architecture: Selection of initial architecture failed");
593 /* Create the ``set architecture'' command appending ``auto'' to the
594 list of architectures. */
596 struct cmd_list_element
*c
;
597 /* Append ``auto''. */
599 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
600 arches
= xrealloc (arches
, sizeof (char*) * (nr
+ 2));
601 arches
[nr
+ 0] = "auto";
602 arches
[nr
+ 1] = NULL
;
603 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
604 of ``const char *''. We just happen to know that the casts are
606 c
= add_set_enum_cmd ("architecture", class_support
,
607 arches
, &set_architecture_string
,
608 "Set architecture of target.",
610 set_cmd_sfunc (c
, set_architecture
);
611 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
612 /* Don't use set_from_show - need to print both auto/manual and
614 add_cmd ("architecture", class_support
, show_architecture
,
615 "Show the current target architecture", &showlist
);
620 /* Initialize a gdbarch info to values that will be automatically
621 overridden. Note: Originally, this ``struct info'' was initialized
622 using memset(0). Unfortunatly, that ran into problems, namely
623 BFD_ENDIAN_BIG is zero. An explicit initialization function that
624 can explicitly set each field to a well defined value is used. */
627 gdbarch_info_init (struct gdbarch_info
*info
)
629 memset (info
, 0, sizeof (struct gdbarch_info
));
630 info
->byte_order
= BFD_ENDIAN_UNKNOWN
;
631 info
->osabi
= GDB_OSABI_UNINITIALIZED
;
636 extern initialize_file_ftype _initialize_gdbarch_utils
; /* -Wmissing-prototypes */
639 _initialize_gdbarch_utils (void)
641 struct cmd_list_element
*c
;
642 c
= add_set_enum_cmd ("endian", class_support
,
643 endian_enum
, &set_endian_string
,
644 "Set endianness of target.",
646 set_cmd_sfunc (c
, set_endian
);
647 /* Don't use set_from_show - need to print both auto/manual and
649 add_cmd ("endian", class_support
, show_endian
,
650 "Show the current byte-order", &showlist
);