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 convert_from_func_ptr_addr_identity (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
226 struct target_ops
*targ
)
232 no_op_reg_to_regnum (int reg
)
238 deprecated_init_frame_pc_default (int fromleaf
, struct frame_info
*prev
)
240 if (fromleaf
&& DEPRECATED_SAVED_PC_AFTER_CALL_P ())
241 return DEPRECATED_SAVED_PC_AFTER_CALL (get_next_frame (prev
));
242 else if (get_next_frame (prev
) != NULL
)
243 return DEPRECATED_FRAME_SAVED_PC (get_next_frame (prev
));
249 default_elf_make_msymbol_special (asymbol
*sym
, struct minimal_symbol
*msym
)
255 default_coff_make_msymbol_special (int val
, struct minimal_symbol
*msym
)
261 cannot_register_not (int regnum
)
266 /* Legacy version of target_virtual_frame_pointer(). Assumes that
267 there is an DEPRECATED_FP_REGNUM and that it is the same, cooked or
271 legacy_virtual_frame_pointer (CORE_ADDR pc
,
273 LONGEST
*frame_offset
)
275 /* FIXME: cagney/2002-09-13: This code is used when identifying the
276 frame pointer of the current PC. It is assuming that a single
277 register and an offset can determine this. I think it should
278 instead generate a byte code expression as that would work better
279 with things like Dwarf2's CFI. */
280 if (DEPRECATED_FP_REGNUM
>= 0 && DEPRECATED_FP_REGNUM
< NUM_REGS
)
281 *frame_regnum
= DEPRECATED_FP_REGNUM
;
282 else if (SP_REGNUM
>= 0 && SP_REGNUM
< NUM_REGS
)
283 *frame_regnum
= SP_REGNUM
;
285 /* Should this be an internal error? I guess so, it is reflecting
286 an architectural limitation in the current design. */
287 internal_error (__FILE__
, __LINE__
, "No virtual frame pointer available");
291 /* Assume the world is sane, every register's virtual and real size
295 generic_register_size (int regnum
)
297 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
298 if (gdbarch_register_type_p (current_gdbarch
))
299 return TYPE_LENGTH (gdbarch_register_type (current_gdbarch
, regnum
));
301 /* FIXME: cagney/2003-03-01: Once all architectures implement
302 gdbarch_register_type(), this entire function can go away. It
303 is made obsolete by register_size(). */
304 return TYPE_LENGTH (DEPRECATED_REGISTER_VIRTUAL_TYPE (regnum
)); /* OK */
307 /* Assume all registers are adjacent. */
310 generic_register_byte (int regnum
)
314 gdb_assert (regnum
>= 0 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
);
316 for (i
= 0; i
< regnum
; i
++)
318 byte
+= generic_register_size (i
);
325 legacy_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
327 #if !defined (IN_SIGTRAMP)
328 if (SIGTRAMP_START_P ())
329 return (pc
) >= SIGTRAMP_START (pc
) && (pc
) < SIGTRAMP_END (pc
);
331 return name
&& strcmp ("_sigtramp", name
) == 0;
333 return IN_SIGTRAMP (pc
, name
);
338 legacy_convert_register_p (int regnum
, struct type
*type
)
340 return DEPRECATED_REGISTER_CONVERTIBLE (regnum
);
344 legacy_register_to_value (struct frame_info
*frame
, int regnum
,
345 struct type
*type
, void *to
)
347 char from
[MAX_REGISTER_SIZE
];
348 get_frame_register (frame
, regnum
, from
);
349 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
, from
, to
);
353 legacy_value_to_register (struct frame_info
*frame
, int regnum
,
354 struct type
*type
, const void *tmp
)
356 char to
[MAX_REGISTER_SIZE
];
357 char *from
= alloca (TYPE_LENGTH (type
));
358 memcpy (from
, from
, TYPE_LENGTH (type
));
359 DEPRECATED_REGISTER_CONVERT_TO_RAW (type
, regnum
, from
, to
);
360 put_frame_register (frame
, regnum
, to
);
364 default_stabs_argument_has_addr (struct gdbarch
*gdbarch
, struct type
*type
)
366 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()
367 && DEPRECATED_REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, type
))
369 CHECK_TYPEDEF (type
);
371 return (TYPE_CODE (type
) == TYPE_CODE_STRUCT
372 || TYPE_CODE (type
) == TYPE_CODE_UNION
373 || TYPE_CODE (type
) == TYPE_CODE_SET
374 || TYPE_CODE (type
) == TYPE_CODE_BITSTRING
);
381 /* Functions to manipulate the endianness of the target. */
383 /* ``target_byte_order'' is only used when non- multi-arch.
384 Multi-arch targets obtain the current byte order using the
385 TARGET_BYTE_ORDER gdbarch method.
387 The choice of initial value is entirely arbitrary. During startup,
388 the function initialize_current_architecture() updates this value
389 based on default byte-order information extracted from BFD. */
390 int target_byte_order
= BFD_ENDIAN_BIG
;
391 int target_byte_order_auto
= 1;
393 static const char endian_big
[] = "big";
394 static const char endian_little
[] = "little";
395 static const char endian_auto
[] = "auto";
396 static const char *endian_enum
[] =
403 static const char *set_endian_string
;
405 /* Called by ``show endian''. */
408 show_endian (char *args
, int from_tty
)
410 if (TARGET_BYTE_ORDER_AUTO
)
411 printf_unfiltered ("The target endianness is set automatically (currently %s endian)\n",
412 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
414 printf_unfiltered ("The target is assumed to be %s endian\n",
415 (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? "big" : "little"));
419 set_endian (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
421 if (set_endian_string
== endian_auto
)
423 target_byte_order_auto
= 1;
425 else if (set_endian_string
== endian_little
)
427 struct gdbarch_info info
;
428 target_byte_order_auto
= 0;
429 gdbarch_info_init (&info
);
430 info
.byte_order
= BFD_ENDIAN_LITTLE
;
431 if (! gdbarch_update_p (info
))
432 printf_unfiltered ("Little endian target not supported by GDB\n");
434 else if (set_endian_string
== endian_big
)
436 struct gdbarch_info info
;
437 target_byte_order_auto
= 0;
438 gdbarch_info_init (&info
);
439 info
.byte_order
= BFD_ENDIAN_BIG
;
440 if (! gdbarch_update_p (info
))
441 printf_unfiltered ("Big endian target not supported by GDB\n");
444 internal_error (__FILE__
, __LINE__
,
445 "set_endian: bad value");
446 show_endian (NULL
, from_tty
);
449 /* Functions to manipulate the architecture of the target */
451 enum set_arch
{ set_arch_auto
, set_arch_manual
};
453 int target_architecture_auto
= 1;
455 const char *set_architecture_string
;
457 /* Called if the user enters ``show architecture'' without an
461 show_architecture (char *args
, int from_tty
)
464 arch
= TARGET_ARCHITECTURE
->printable_name
;
465 if (target_architecture_auto
)
466 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
468 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
472 /* Called if the user enters ``set architecture'' with or without an
476 set_architecture (char *ignore_args
, int from_tty
, struct cmd_list_element
*c
)
478 if (strcmp (set_architecture_string
, "auto") == 0)
480 target_architecture_auto
= 1;
484 struct gdbarch_info info
;
485 gdbarch_info_init (&info
);
486 info
.bfd_arch_info
= bfd_scan_arch (set_architecture_string
);
487 if (info
.bfd_arch_info
== NULL
)
488 internal_error (__FILE__
, __LINE__
,
489 "set_architecture: bfd_scan_arch failed");
490 if (gdbarch_update_p (info
))
491 target_architecture_auto
= 0;
493 printf_unfiltered ("Architecture `%s' not recognized.\n",
494 set_architecture_string
);
496 show_architecture (NULL
, from_tty
);
499 /* Set the dynamic target-system-dependent parameters (architecture,
500 byte-order) using information found in the BFD */
503 set_gdbarch_from_file (bfd
*abfd
)
505 struct gdbarch_info info
;
506 gdbarch_info_init (&info
);
508 if (! gdbarch_update_p (info
))
509 error ("Architecture of file not recognized.\n");
512 /* Initialize the current architecture. Update the ``set
513 architecture'' command so that it specifies a list of valid
516 #ifdef DEFAULT_BFD_ARCH
517 extern const bfd_arch_info_type DEFAULT_BFD_ARCH
;
518 static const bfd_arch_info_type
*default_bfd_arch
= &DEFAULT_BFD_ARCH
;
520 static const bfd_arch_info_type
*default_bfd_arch
;
523 #ifdef DEFAULT_BFD_VEC
524 extern const bfd_target DEFAULT_BFD_VEC
;
525 static const bfd_target
*default_bfd_vec
= &DEFAULT_BFD_VEC
;
527 static const bfd_target
*default_bfd_vec
;
531 initialize_current_architecture (void)
533 const char **arches
= gdbarch_printable_names ();
535 /* determine a default architecture and byte order. */
536 struct gdbarch_info info
;
537 gdbarch_info_init (&info
);
539 /* Find a default architecture. */
540 if (info
.bfd_arch_info
== NULL
541 && default_bfd_arch
!= NULL
)
542 info
.bfd_arch_info
= default_bfd_arch
;
543 if (info
.bfd_arch_info
== NULL
)
545 /* Choose the architecture by taking the first one
547 const char *chosen
= arches
[0];
549 for (arch
= arches
; *arch
!= NULL
; arch
++)
551 if (strcmp (*arch
, chosen
) < 0)
555 internal_error (__FILE__
, __LINE__
,
556 "initialize_current_architecture: No arch");
557 info
.bfd_arch_info
= bfd_scan_arch (chosen
);
558 if (info
.bfd_arch_info
== NULL
)
559 internal_error (__FILE__
, __LINE__
,
560 "initialize_current_architecture: Arch not found");
563 /* Take several guesses at a byte order. */
564 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
565 && default_bfd_vec
!= NULL
)
567 /* Extract BFD's default vector's byte order. */
568 switch (default_bfd_vec
->byteorder
)
571 info
.byte_order
= BFD_ENDIAN_BIG
;
573 case BFD_ENDIAN_LITTLE
:
574 info
.byte_order
= BFD_ENDIAN_LITTLE
;
580 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
582 /* look for ``*el-*'' in the target name. */
584 chp
= strchr (target_name
, '-');
586 && chp
- 2 >= target_name
587 && strncmp (chp
- 2, "el", 2) == 0)
588 info
.byte_order
= BFD_ENDIAN_LITTLE
;
590 if (info
.byte_order
== BFD_ENDIAN_UNKNOWN
)
592 /* Wire it to big-endian!!! */
593 info
.byte_order
= BFD_ENDIAN_BIG
;
596 if (! gdbarch_update_p (info
))
597 internal_error (__FILE__
, __LINE__
,
598 "initialize_current_architecture: Selection of initial architecture failed");
600 /* Create the ``set architecture'' command appending ``auto'' to the
601 list of architectures. */
603 struct cmd_list_element
*c
;
604 /* Append ``auto''. */
606 for (nr
= 0; arches
[nr
] != NULL
; nr
++);
607 arches
= xrealloc (arches
, sizeof (char*) * (nr
+ 2));
608 arches
[nr
+ 0] = "auto";
609 arches
[nr
+ 1] = NULL
;
610 /* FIXME: add_set_enum_cmd() uses an array of ``char *'' instead
611 of ``const char *''. We just happen to know that the casts are
613 c
= add_set_enum_cmd ("architecture", class_support
,
614 arches
, &set_architecture_string
,
615 "Set architecture of target.",
617 set_cmd_sfunc (c
, set_architecture
);
618 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
619 /* Don't use set_from_show - need to print both auto/manual and
621 add_cmd ("architecture", class_support
, show_architecture
,
622 "Show the current target architecture", &showlist
);
627 /* Initialize a gdbarch info to values that will be automatically
628 overridden. Note: Originally, this ``struct info'' was initialized
629 using memset(0). Unfortunately, that ran into problems, namely
630 BFD_ENDIAN_BIG is zero. An explicit initialization function that
631 can explicitly set each field to a well defined value is used. */
634 gdbarch_info_init (struct gdbarch_info
*info
)
636 memset (info
, 0, sizeof (struct gdbarch_info
));
637 info
->byte_order
= BFD_ENDIAN_UNKNOWN
;
638 info
->osabi
= GDB_OSABI_UNINITIALIZED
;
643 extern initialize_file_ftype _initialize_gdbarch_utils
; /* -Wmissing-prototypes */
646 _initialize_gdbarch_utils (void)
648 struct cmd_list_element
*c
;
649 c
= add_set_enum_cmd ("endian", class_support
,
650 endian_enum
, &set_endian_string
,
651 "Set endianness of target.",
653 set_cmd_sfunc (c
, set_endian
);
654 /* Don't use set_from_show - need to print both auto/manual and
656 add_cmd ("endian", class_support
, show_endian
,
657 "Show the current byte-order", &showlist
);