3 # Architecture commands for GDB, the GNU debugger.
4 # Copyright 1998-1999 Free Software Foundation, Inc.
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, Boston, MA 02111-1307, USA.
24 read="class level macro returntype function formal actual attrib default init init_p fmt print print_p description"
36 # formal argument list
37 # actual argument list
45 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct:::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
47 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
49 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
50 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
51 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
52 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
53 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
54 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
55 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
56 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
57 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
59 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
60 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
61 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
62 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
63 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
64 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
66 v:2:NUM_REGS:int:num_regs::::0:-1
67 v:2:SP_REGNUM:int:sp_regnum::::0:-1
68 v:2:FP_REGNUM:int:fp_regnum::::0:-1
69 v:2:PC_REGNUM:int:pc_regnum::::0:-1
70 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr::0:0
71 v:2:REGISTER_SIZE:int:register_size::::0:-1
72 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
73 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
74 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
75 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
76 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
77 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
78 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
80 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
81 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
82 f:2:CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void:::0:0:gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0:
83 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1::0x%08lx
84 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::0x%08lx
85 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
86 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
87 f:2:PC_IN_CALL_DUMMY:int:pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::0:0
88 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
89 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:::0x%08lx
90 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:::0x%08lx
91 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1::0x%08lx
92 v:2:CALL_DUMMY_STACK_ADJUST:int:call_dummy_stack_adjust::::0::gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0:0x%08lx::CALL_DUMMY_STACK_ADJUST_P
93 f:2:FIX_CALL_DUMMY:void:fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p::0:0
95 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::0:::::#
96 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::0:::::#
97 f:1:GET_SAVED_REGISTER:void:get_saved_register:char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval:raw_buffer, optimized, addrp, frame, regnum, lval::generic_get_saved_register:0
99 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr::0:0
100 f:2:REGISTER_CONVERT_TO_VIRTUAL:void:register_convert_to_virtual:int regnum, struct type *type, char *from, char *to:regnum, type, from, to::0:0
101 f:2:REGISTER_CONVERT_TO_RAW:void:register_convert_to_raw:struct type *type, int regnum, char *from, char *to:type, regnum, from, to::0:0
103 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
104 f:1:PUSH_ARGUMENTS:CORE_ADDR:push_arguments:int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr:nargs, args, sp, struct_return, struct_addr::0:0
105 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-::0:0
106 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp::0:0
107 f:2:POP_FRAME:void:pop_frame:void:-::0:0
109 # I wish that these would just go away....
110 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x::0:0
111 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x::0:0
112 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x::0:0
113 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x::0:0
114 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x::0:0
115 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x::0:0
117 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp::0:0
118 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf::0:0
119 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf::0:0
120 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type::0:0
122 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
123 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame::0:0
125 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
126 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
127 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:0
128 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
129 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
131 f:2:REMOTE_TRANSLATE_XFER_ADDRESS:void:remote_translate_xfer_address:CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len:gdb_addr, gdb_len, rem_addr, rem_len::0:0
133 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
134 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi::0:0
135 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
136 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
137 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
138 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
139 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
140 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
141 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
152 function_list |
while eval read $read
155 ${class} ${macro}(${actual})
156 ${returntype} ${function} ($formal)${attrib}
164 description=${description}
173 /* Dynamic architecture support for GDB, the GNU debugger.
174 Copyright 1998-1999, Free Software Foundation, Inc.
176 This file is part of GDB.
178 This program is free software; you can redistribute it and/or modify
179 it under the terms of the GNU General Public License as published by
180 the Free Software Foundation; either version 2 of the License, or
181 (at your option) any later version.
183 This program is distributed in the hope that it will be useful,
184 but WITHOUT ANY WARRANTY; without even the implied warranty of
185 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
186 GNU General Public License for more details.
188 You should have received a copy of the GNU General Public License
189 along with this program; if not, write to the Free Software
190 Foundation, Inc., 59 Temple Place - Suite 330,
191 Boston, MA 02111-1307, USA. */
193 /* *INDENT-OFF* */ /* \`\`typedef (f)();'' confuses indent */
195 /* This file was created with the aid of \`\`gdbarch.sh''.
197 The bourn shell script \`\`gdbarch.sh'' creates the files
198 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
199 against the existing \`\`gdbarch.[hc]''. Any differences found
202 If editing this file, please also run gdbarch.sh and merge any
203 changes into that script. Conversely, when makeing sweeping changes
204 to this file, modifying gdbarch.sh and using its output may prove
224 #ifndef GDB_MULTI_ARCH
225 #define GDB_MULTI_ARCH 0
228 extern struct gdbarch *current_gdbarch;
231 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
235 /* If any of the following are defined, the target wasn't correctly
239 #if defined (CALL_DUMMY)
240 #error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
245 #if defined (REGISTER_NAMES)
246 #error "REGISTER_NAMES: replaced by REGISTER_NAME"
251 #if defined (EXTRA_FRAME_INFO)
252 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
257 #if defined (FRAME_FIND_SAVED_REGS)
258 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
266 echo "/* The following are pre-initialized by GDBARCH. */"
267 function_list |
while eval read $read
272 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
273 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
274 echo "#if GDB_MULTI_ARCH"
275 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
276 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
286 echo "/* The following are initialized by the target dependant code. */"
287 function_list |
while eval read $read
292 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
293 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
294 echo "#if GDB_MULTI_ARCH"
295 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
296 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
302 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
303 if [ "${formal}" = "void" ]
305 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
307 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
309 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
310 echo "#if GDB_MULTI_ARCH"
311 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
312 if [ "${actual}" = "" ]
314 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
315 elif [ "${actual}" = "-" ]
317 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
319 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
330 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
333 /* Mechanism for co-ordinating the selection of a specific
336 GDB targets (*-tdep.c) can register an interest in a specific
337 architecture. Other GDB components can register a need to maintain
338 per-architecture data.
340 The mechanisms below ensures that there is only a loose connection
341 between the set-architecture command and the various GDB
342 components. Each component can independantly register their need
343 to maintain architecture specific data with gdbarch.
347 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
350 The more traditional mega-struct containing architecture specific
351 data for all the various GDB components was also considered. Since
352 GDB is built from a variable number of (fairly independant)
353 components it was determined that the global aproach was not
357 /* Register a new architectural family with GDB.
359 Register support for the specified ARCHITECTURE with GDB. When
360 gdbarch determines that the specified architecture has been
361 selected, the corresponding INIT function is called.
365 The INIT function takes two parameters: INFO which contains the
366 information available to gdbarch about the (possibly new)
367 architecture; ARCHES which is a list of the previously created
368 \`\`struct gdbarch'' for this architecture.
370 The INIT function parameter INFO shall, as far as possible, be
371 pre-initialized with information obtained from INFO.ABFD or
372 previously selected architecture (if similar). INIT shall ensure
373 that the INFO.BYTE_ORDER is non-zero.
375 The INIT function shall return any of: NULL - indicating that it
376 doesn't reconize the selected architecture; an existing \`\`struct
377 gdbarch'' from the ARCHES list - indicating that the new
378 architecture is just a synonym for an earlier architecture (see
379 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
380 - that describes the selected architecture (see
385 struct gdbarch *gdbarch;
386 struct gdbarch_list *next;
391 /* Use default: bfd_arch_unknown (ZERO). */
392 enum bfd_architecture bfd_architecture;
394 /* Use default: NULL (ZERO). */
395 const struct bfd_arch_info *bfd_arch_info;
397 /* Use default: 0 (ZERO). */
400 /* Use default: NULL (ZERO). */
403 /* Use default: NULL (ZERO). */
404 struct gdbarch_tdep_info *tdep_info;
407 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
409 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
412 /* Helper function. Search the list of ARCHES for a GDBARCH that
413 matches the information provided by INFO. */
415 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
418 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
419 basic initialization using values obtained from the INFO andTDEP
420 parameters. set_gdbarch_*() functions are called to complete the
421 initialization of the object. */
423 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
426 /* Helper function. Force an update of the current architecture. Used
427 by legacy targets that have added their own target specific
428 architecture manipulation commands.
430 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
431 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
432 called. gdbarch_update() shall initialize any \`\`default'' fields
433 using information obtained from the previous architecture or
434 INFO.ABFD (if specified) before calling the corresponding
435 architectures INIT function. */
437 extern int gdbarch_update (struct gdbarch_info info);
441 /* Register per-architecture data-pointer.
443 Reserve space for a per-architecture data-pointer. An identifier
444 for the reserved data-pointer is returned. That identifer should
445 be saved in a local static.
447 When a new architecture is selected, INIT() is called. When a
448 previous architecture is re-selected, the per-architecture
449 data-pointer for that previous architecture is restored (INIT() is
452 INIT() shall return the initial value for the per-architecture
453 data-pointer for the current architecture.
455 Multiple registrarants for any architecture are allowed (and
456 strongly encouraged). */
458 typedef void *(gdbarch_data_ftype) (void);
459 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
461 /* Return the value of the per-architecture data-pointer for the
462 current architecture. */
464 extern void *gdbarch_data (struct gdbarch_data*);
468 /* Register per-architecture memory region.
470 Provide a memory-region swap mechanism. Per-architecture memory
471 region are created. These memory regions are swapped whenever the
472 architecture is changed. For a new architecture, the memory region
473 is initialized with zero (0) and the INIT function is called.
475 Memory regions are swapped / initialized in the order that they are
476 registered. NULL DATA and/or INIT values can be specified.
478 New code should use register_gdbarch_data(). */
480 typedef void (gdbarch_swap_ftype) (void);
481 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
485 /* The target-system-dependant byte order is dynamic */
487 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
488 is selectable at runtime. The user can use the \`\`set endian''
489 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
490 target_byte_order should be auto-detected (from the program image
494 /* Multi-arch GDB is always bi-endian. */
495 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
498 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
499 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
500 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
501 #ifdef TARGET_BYTE_ORDER_SELECTABLE
502 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
504 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
508 extern int target_byte_order;
509 #ifdef TARGET_BYTE_ORDER_SELECTABLE
510 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
511 and expect defs.h to re-define TARGET_BYTE_ORDER. */
512 #undef TARGET_BYTE_ORDER
514 #ifndef TARGET_BYTE_ORDER
515 #define TARGET_BYTE_ORDER (target_byte_order + 0)
518 extern int target_byte_order_auto;
519 #ifndef TARGET_BYTE_ORDER_AUTO
520 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
525 /* The target-system-dependant BFD architecture is dynamic */
527 extern int target_architecture_auto;
528 #ifndef TARGET_ARCHITECTURE_AUTO
529 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
532 extern const struct bfd_arch_info *target_architecture;
533 #ifndef TARGET_ARCHITECTURE
534 #define TARGET_ARCHITECTURE (target_architecture + 0)
537 /* Notify the target dependant backend of a change to the selected
538 architecture. A zero return status indicates that the target did
539 not like the change. */
541 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
545 /* The target-system-dependant disassembler is semi-dynamic */
547 #include "dis-asm.h" /* Get defs for disassemble_info */
549 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
550 int len, disassemble_info *info);
552 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
553 disassemble_info *info);
555 extern void dis_asm_print_address (bfd_vma addr,
556 disassemble_info *info);
558 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
559 extern disassemble_info tm_print_insn_info;
560 #ifndef TARGET_PRINT_INSN
561 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
563 #ifndef TARGET_PRINT_INSN_INFO
564 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
569 /* Explicit test for D10V architecture.
570 USE of these macro's is *STRONGLY* discouraged. */
572 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
573 #ifndef D10V_MAKE_DADDR
574 #define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
576 #ifndef D10V_MAKE_IADDR
577 #define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
581 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
582 #ifndef FRAMELESS_FUNCTION_INVOCATION
583 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
587 /* Fallback definition of REGISTER_CONVERTIBLE etc */
588 extern int generic_register_convertible_not (int reg_nr);
589 #ifndef REGISTER_CONVERTIBLE
590 #define REGISTER_CONVERTIBLE(x) (0)
592 #ifndef REGISTER_CONVERT_TO_VIRTUAL
593 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
595 #ifndef REGISTER_CONVERT_TO_RAW
596 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
600 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
601 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
602 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
603 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
605 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
606 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
611 /* Fallback definition for REGISTER_NAME for systems still defining
613 #ifndef REGISTER_NAME
614 extern char *gdb_register_names[];
615 #define REGISTER_NAME(i) gdb_register_names[i]
619 /* Set the dynamic target-system-dependant parameters (architecture,
620 byte-order, ...) using information found in the BFD */
622 extern void set_gdbarch_from_file (bfd *);
625 /* Explicitly set the dynamic target-system-dependant parameters based
626 on bfd_architecture and machine. */
628 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
631 /* Helper function for targets that don't know how my arguments are
634 extern int frame_num_args_unknown (struct frame_info *fi);
637 /* gdbarch trace variable */
638 extern int gdbarch_debug;
640 extern void gdbarch_dump (void);
645 #../move-if-change new-gdbarch.h gdbarch.h
646 if ! test -r gdbarch.h
648 echo "gdbarch.h missing? cp new-gdbarch.h gdbarch.h" 1>&2
649 elif diff -c gdbarch.h new-gdbarch.h
651 echo "gdbarch.h unchanged" 1>&2
653 echo "gdbarch.h has changed? cp new-gdbarch.h gdbarch.h" 1>&2
669 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
671 /* Just include everything in sight so that the every old definition
672 of macro is visible. */
673 #include "gdb_string.h"
677 #include "inferior.h"
678 #include "breakpoint.h"
683 #include "gdbthread.h"
684 #include "annotate.h"
685 #include "symfile.h" /* for overlay functions */
690 /* Static function declarations */
692 static void verify_gdbarch (struct gdbarch *gdbarch);
693 static void init_gdbarch_data (struct gdbarch *);
694 static void init_gdbarch_swap (struct gdbarch *);
695 static void swapout_gdbarch_swap (struct gdbarch *);
696 static void swapin_gdbarch_swap (struct gdbarch *);
698 /* Convenience macro for allocting typesafe memory. */
701 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
705 /* Non-zero if we want to trace architecture code. */
707 #ifndef GDBARCH_DEBUG
708 #define GDBARCH_DEBUG 0
710 int gdbarch_debug = GDBARCH_DEBUG;
714 # gdbarch open the gdbarch object
716 echo "/* Maintain the struct gdbarch object */"
718 echo "struct gdbarch"
720 echo " /* basic architectural information */"
721 function_list |
while eval read $read
724 "i" ) echo " ${returntype} ${function};" ;;
728 echo " /* target specific vector. */"
729 echo " struct gdbarch_tdep *tdep;"
731 echo " /* per-architecture data-pointers */"
735 echo " /* per-architecture swap-regions */"
736 echo " struct gdbarch_swap *swap;"
739 /* Multi-arch values.
741 When extending this structure you must:
745 Declare set/get functions and define the corresponding
748 gdbarch_alloc(): If zero/NULL is not a suitable default,
749 initialize the new field.
751 verify_gdbarch(): Confirm that the target updated the field
754 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
757 \`\`default_gdbarch()'': Append an initial value to the static
758 variable (base values on the host's c-type system).
760 get_gdbarch(): Implement the set/get functions (probably using
761 the macro's as shortcuts).
766 function_list |
while eval read $read
769 "v" ) echo " ${returntype} ${function};" ;;
770 "f" ) echo " gdbarch_${function}_ftype *${function}${attrib};" ;;
775 # A pre-initialized vector
779 /* The default architecture uses host values (for want of a better
783 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
785 echo "struct gdbarch default_gdbarch = {"
786 echo " /* basic architecture information */"
787 function_list |
while eval read $read
790 "i" ) echo " ${default}," ;;
794 /* target specific vector */
796 /*per-architecture data-pointers and swap regions */
798 /* Multi-arch values */
800 function_list |
while eval read $read
803 "f" |
"v" ) echo " ${default}," ;;
807 /* default_gdbarch() */
809 struct gdbarch *current_gdbarch = &default_gdbarch;
812 # Create a new gdbarch struct
816 /* Create a new \`\`struct gdbarch'' based in information provided by
817 \`\`struct gdbarch_info''. */
822 gdbarch_alloc (const struct gdbarch_info *info,
823 struct gdbarch_tdep *tdep)
825 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
826 memset (gdbarch, 0, sizeof (*gdbarch));
828 gdbarch->tdep = tdep;
831 function_list |
while eval read $read
834 "i" ) echo " gdbarch->${function} = info->${function};"
838 echo " /* Force the explicit initialization of these. */"
839 function_list |
while eval read $read
843 if [ "${init}" != "" -a "${init}" != "0" ]
845 echo " gdbarch->${function} = ${init};"
851 /* gdbarch_alloc() */
857 # verify a new architecture
860 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
864 verify_gdbarch (struct gdbarch *gdbarch)
866 /* Only perform sanity checks on a multi-arch target. */
867 if (GDB_MULTI_ARCH <= 0)
870 if (gdbarch->byte_order == 0)
871 internal_error ("verify_gdbarch: byte-order unset");
872 if (gdbarch->bfd_arch_info == NULL)
873 internal_error ("verify_gdbarch: bfd_arch_info unset");
874 /* Check those that need to be defined for the given multi-arch level. */
876 function_list |
while eval read $read
882 echo " if ((GDB_MULTI_ARCH >= ${level})"
883 echo " && (${init_p}))"
884 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
887 echo " if ((GDB_MULTI_ARCH >= ${level})"
888 echo " && (gdbarch->${function} == ${init}))"
889 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
901 echo "/* Print out the details of the current architecture. */"
908 function_list |
while eval read $read
912 echo " fprintf_unfiltered (gdb_stdlog,"
913 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
914 echo " (long) current_gdbarch->${function}"
915 echo " /*${macro} ()*/);"
918 test "${fmt}" ||
fmt="%ld"
919 test "${print}" || print
="(long) ${macro}"
920 if [ "${print_p}" = "#" ]
922 echo "#ifdef ${macro}"
923 echo " fprintf_unfiltered (gdb_stdlog,"
924 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
927 elif [ "${print_p}" ]
929 echo " if (${print_p})"
930 echo " fprintf_unfiltered (gdb_stdlog,"
931 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
934 echo " fprintf_unfiltered (gdb_stdlog,"
935 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
947 struct gdbarch_tdep *
948 gdbarch_tdep (struct gdbarch *gdbarch)
950 if (gdbarch_debug >= 2)
951 /* FIXME: gdb_std??? */
952 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
953 return gdbarch->tdep;
957 function_list |
while eval read $read
963 if [ "${formal}" = "void" ]
965 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
967 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
970 echo " if (gdbarch->${function} == 0)"
971 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
972 echo " if (gdbarch_debug >= 2)"
973 echo " /* FIXME: gdb_std??? */"
974 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
975 test "${actual}" = "-" && actual
=""
976 if [ "${returntype}" = "void" ]
978 echo " gdbarch->${function} (${actual});"
980 echo " return gdbarch->${function} (${actual});"
985 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
986 echo " `echo ${function} | tr '[0-9a-z_]' ' '` gdbarch_${function}_ftype ${function})"
988 echo " gdbarch->${function} = ${function};"
994 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
998 echo " if (${init_p})"
999 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1002 echo " if (gdbarch->${function} == ${init})"
1003 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1005 echo " if (gdbarch_debug >= 2)"
1006 echo " /* FIXME: gdb_std??? */"
1007 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1008 echo " return gdbarch->${function};"
1012 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1013 echo " `echo ${function} | tr '[0-9a-z_]' ' '` ${returntype} ${function})"
1015 echo " gdbarch->${function} = ${function};"
1020 echo "${returntype}"
1021 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1023 echo " if (gdbarch_debug >= 2)"
1024 echo " /* FIXME: gdb_std??? */"
1025 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1026 echo " return gdbarch->${function};"
1032 # All the trailing guff
1036 /* Keep a registrary of per-architecture data-pointers required by GDB
1044 struct gdbarch_data_registration
1046 gdbarch_data_ftype *init;
1047 struct gdbarch_data *data;
1048 struct gdbarch_data_registration *next;
1051 struct gdbarch_data_registrary
1054 struct gdbarch_data_registration *registrations;
1057 struct gdbarch_data_registrary gdbarch_data_registrary =
1062 struct gdbarch_data *
1063 register_gdbarch_data (gdbarch_data_ftype *init)
1065 struct gdbarch_data_registration **curr;
1066 for (curr = &gdbarch_data_registrary.registrations;
1068 curr = &(*curr)->next);
1069 (*curr) = XMALLOC (struct gdbarch_data_registration);
1070 (*curr)->next = NULL;
1071 (*curr)->init = init;
1072 (*curr)->data = XMALLOC (struct gdbarch_data);
1073 (*curr)->data->index = gdbarch_data_registrary.nr++;
1074 return (*curr)->data;
1078 /* Walk through all the registered users initializing each in turn. */
1081 init_gdbarch_data (struct gdbarch *gdbarch)
1083 struct gdbarch_data_registration *rego;
1084 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1085 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1086 for (rego = gdbarch_data_registrary.registrations;
1090 if (rego->data->index < gdbarch->nr_data)
1091 gdbarch->data[rego->data->index] = rego->init ();
1096 /* Return the current value of the specified per-architecture
1101 struct gdbarch_data *data;
1103 if (data->index >= current_gdbarch->nr_data)
1104 internal_error ("gdbarch_data: request for non-existant data.");
1105 return current_gdbarch->data[data->index];
1110 /* Keep a registrary of swaped data required by GDB modules. */
1115 struct gdbarch_swap_registration *source;
1116 struct gdbarch_swap *next;
1119 struct gdbarch_swap_registration
1122 unsigned long sizeof_data;
1123 gdbarch_swap_ftype *init;
1124 struct gdbarch_swap_registration *next;
1127 struct gdbarch_swap_registrary
1130 struct gdbarch_swap_registration *registrations;
1133 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1139 register_gdbarch_swap (void *data,
1140 unsigned long sizeof_data,
1141 gdbarch_swap_ftype *init)
1143 struct gdbarch_swap_registration **rego;
1144 for (rego = &gdbarch_swap_registrary.registrations;
1146 rego = &(*rego)->next);
1147 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1148 (*rego)->next = NULL;
1149 (*rego)->init = init;
1150 (*rego)->data = data;
1151 (*rego)->sizeof_data = sizeof_data;
1156 init_gdbarch_swap (struct gdbarch *gdbarch)
1158 struct gdbarch_swap_registration *rego;
1159 struct gdbarch_swap **curr = &gdbarch->swap;
1160 for (rego = gdbarch_swap_registrary.registrations;
1164 if (rego->data != NULL)
1166 (*curr) = XMALLOC (struct gdbarch_swap);
1167 (*curr)->source = rego;
1168 (*curr)->swap = xmalloc (rego->sizeof_data);
1169 (*curr)->next = NULL;
1170 memset (rego->data, 0, rego->sizeof_data);
1171 curr = &(*curr)->next;
1173 if (rego->init != NULL)
1179 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1181 struct gdbarch_swap *curr;
1182 for (curr = gdbarch->swap;
1185 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1189 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1191 struct gdbarch_swap *curr;
1192 for (curr = gdbarch->swap;
1195 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1199 /* Keep a registrary of the architectures known by GDB. */
1201 struct gdbarch_init_registration
1203 enum bfd_architecture bfd_architecture;
1204 gdbarch_init_ftype *init;
1205 struct gdbarch_list *arches;
1206 struct gdbarch_init_registration *next;
1209 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1212 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1213 gdbarch_init_ftype *init)
1215 struct gdbarch_init_registration **curr;
1216 const struct bfd_arch_info *bfd_arch_info;
1217 /* Check that BFD reconizes this architecture */
1218 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1219 if (bfd_arch_info == NULL)
1221 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1223 /* Check that we haven't seen this architecture before */
1224 for (curr = &gdbarch_init_registrary;
1226 curr = &(*curr)->next)
1228 if (bfd_architecture == (*curr)->bfd_architecture)
1229 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1230 bfd_arch_info->printable_name);
1234 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1235 bfd_arch_info->printable_name,
1238 (*curr) = XMALLOC (struct gdbarch_init_registration);
1239 (*curr)->bfd_architecture = bfd_architecture;
1240 (*curr)->init = init;
1241 (*curr)->arches = NULL;
1242 (*curr)->next = NULL;
1247 /* Look for an architecture using gdbarch_info. Base search on only
1248 BFD_ARCH_INFO and BYTE_ORDER. */
1250 struct gdbarch_list *
1251 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1252 const struct gdbarch_info *info)
1254 for (; arches != NULL; arches = arches->next)
1256 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1258 if (info->byte_order != arches->gdbarch->byte_order)
1266 /* Update the current architecture. Return ZERO if the update request
1270 gdbarch_update (struct gdbarch_info info)
1272 struct gdbarch *new_gdbarch;
1273 struct gdbarch_list **list;
1274 struct gdbarch_init_registration *rego;
1276 /* Fill in any missing bits. Most important is the bfd_architecture
1277 which is used to select the target architecture. */
1278 if (info.bfd_architecture == bfd_arch_unknown)
1280 if (info.bfd_arch_info != NULL)
1281 info.bfd_architecture = info.bfd_arch_info->arch;
1282 else if (info.abfd != NULL)
1283 info.bfd_architecture = bfd_get_arch (info.abfd);
1284 /* FIXME - should query BFD for its default architecture. */
1286 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1288 if (info.bfd_arch_info == NULL)
1290 if (target_architecture_auto && info.abfd != NULL)
1291 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1293 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1295 if (info.byte_order == 0)
1297 if (target_byte_order_auto && info.abfd != NULL)
1298 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1299 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1302 info.byte_order = current_gdbarch->byte_order;
1303 /* FIXME - should query BFD for its default byte-order. */
1305 /* A default for abfd? */
1307 /* Find the target that knows about this architecture. */
1308 for (rego = gdbarch_init_registrary;
1309 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1314 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1320 fprintf_unfiltered (gdb_stdlog,
1321 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1322 info.bfd_architecture,
1323 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1324 fprintf_unfiltered (gdb_stdlog,
1325 "gdbarch_update: info.bfd_arch_info %s\n",
1326 (info.bfd_arch_info != NULL
1327 ? info.bfd_arch_info->printable_name
1329 fprintf_unfiltered (gdb_stdlog,
1330 "gdbarch_update: info.byte_order %d (%s)\n",
1332 (info.byte_order == BIG_ENDIAN ? "big"
1333 : info.byte_order == LITTLE_ENDIAN ? "little"
1335 fprintf_unfiltered (gdb_stdlog,
1336 "gdbarch_update: info.abfd 0x%lx\n",
1338 fprintf_unfiltered (gdb_stdlog,
1339 "gdbarch_update: info.tdep_info 0x%lx\n",
1340 (long) info.tdep_info);
1343 /* Ask the target for a replacement architecture. */
1344 new_gdbarch = rego->init (info, rego->arches);
1346 /* Did the target like it? No. Reject the change. */
1347 if (new_gdbarch == NULL)
1350 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1354 /* Did the architecture change? No. Do nothing. */
1355 if (current_gdbarch == new_gdbarch)
1358 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1360 new_gdbarch->bfd_arch_info->printable_name);
1364 /* Swap all data belonging to the old target out */
1365 swapout_gdbarch_swap (current_gdbarch);
1367 /* Is this a pre-existing architecture? Yes. Swap it in. */
1368 for (list = ®o->arches;
1370 list = &(*list)->next)
1372 if ((*list)->gdbarch == new_gdbarch)
1375 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1377 new_gdbarch->bfd_arch_info->printable_name);
1378 current_gdbarch = new_gdbarch;
1379 swapin_gdbarch_swap (new_gdbarch);
1384 /* Append this new architecture to this targets list. */
1385 (*list) = XMALLOC (struct gdbarch_list);
1386 (*list)->next = NULL;
1387 (*list)->gdbarch = new_gdbarch;
1389 /* Switch to this new architecture. Dump it out. */
1390 current_gdbarch = new_gdbarch;
1393 fprintf_unfiltered (gdb_stdlog,
1394 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1396 new_gdbarch->bfd_arch_info->printable_name);
1400 /* Check that the newly installed architecture is valid. */
1401 verify_gdbarch (new_gdbarch);
1403 /* Initialize the per-architecture memory (swap) areas.
1404 CURRENT_GDBARCH must be update before these modules are
1406 init_gdbarch_swap (new_gdbarch);
1408 /* Initialize the per-architecture data-pointer of all parties that
1409 registered an interest in this architecture. CURRENT_GDBARCH
1410 must be updated before these modules are called. */
1411 init_gdbarch_data (new_gdbarch);
1418 /* Functions to manipulate the endianness of the target. */
1420 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1421 /* compat - Catch old targets that expect a selectable byte-order to
1422 default to BIG_ENDIAN */
1423 #ifndef TARGET_BYTE_ORDER_DEFAULT
1424 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1427 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1428 #ifndef TARGET_BYTE_ORDER_DEFAULT
1429 /* compat - Catch old non byte-order selectable targets that do not
1430 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1431 TARGET_BYTE_ORDER to be used as the default. For targets that
1432 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1433 below will get a strange compiler warning. */
1434 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1437 #ifndef TARGET_BYTE_ORDER_DEFAULT
1438 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1440 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1441 int target_byte_order_auto = 1;
1443 /* Chain containing the \"set endian\" commands. */
1444 static struct cmd_list_element *endianlist = NULL;
1446 /* Called by \`\`show endian''. */
1448 show_endian (char *args, int from_tty)
1451 (TARGET_BYTE_ORDER_AUTO
1452 ? "The target endianness is set automatically (currently %s endian)\n"
1453 : "The target is assumed to be %s endian\n");
1454 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1457 /* Called if the user enters \`\`set endian'' without an argument. */
1459 set_endian (char *args, int from_tty)
1461 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1462 show_endian (args, from_tty);
1465 /* Called by \`\`set endian big''. */
1467 set_endian_big (char *args, int from_tty)
1469 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1471 target_byte_order = BIG_ENDIAN;
1472 target_byte_order_auto = 0;
1475 struct gdbarch_info info;
1476 memset (&info, 0, sizeof info);
1477 info.byte_order = BIG_ENDIAN;
1478 gdbarch_update (info);
1483 printf_unfiltered ("Byte order is not selectable.");
1484 show_endian (args, from_tty);
1488 /* Called by \`\`set endian little''. */
1490 set_endian_little (char *args, int from_tty)
1492 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1494 target_byte_order = LITTLE_ENDIAN;
1495 target_byte_order_auto = 0;
1498 struct gdbarch_info info;
1499 memset (&info, 0, sizeof info);
1500 info.byte_order = LITTLE_ENDIAN;
1501 gdbarch_update (info);
1506 printf_unfiltered ("Byte order is not selectable.");
1507 show_endian (args, from_tty);
1511 /* Called by \`\`set endian auto''. */
1513 set_endian_auto (char *args, int from_tty)
1515 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1517 target_byte_order_auto = 1;
1521 printf_unfiltered ("Byte order is not selectable.");
1522 show_endian (args, from_tty);
1526 /* Set the endianness from a BFD. */
1528 set_endian_from_file (bfd *abfd)
1530 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1534 if (bfd_big_endian (abfd))
1537 want = LITTLE_ENDIAN;
1538 if (TARGET_BYTE_ORDER_AUTO)
1539 target_byte_order = want;
1540 else if (TARGET_BYTE_ORDER != want)
1541 warning ("%s endian file does not match %s endian target.",
1542 want == BIG_ENDIAN ? "big" : "little",
1543 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1547 if (bfd_big_endian (abfd)
1548 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1549 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1550 warning ("%s endian file does not match %s endian target.",
1551 bfd_big_endian (abfd) ? "big" : "little",
1552 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1558 /* Functions to manipulate the architecture of the target */
1560 enum set_arch { set_arch_auto, set_arch_manual };
1562 int target_architecture_auto = 1;
1563 extern const struct bfd_arch_info bfd_default_arch_struct;
1564 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1565 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1567 static void show_endian (char *, int);
1568 static void set_endian (char *, int);
1569 static void set_endian_big (char *, int);
1570 static void set_endian_little (char *, int);
1571 static void set_endian_auto (char *, int);
1572 static void set_endian_from_file (bfd *);
1573 static int arch_ok (const struct bfd_arch_info *arch);
1574 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1575 static void show_architecture (char *, int);
1576 static void set_architecture (char *, int);
1577 static void info_architecture (char *, int);
1578 static void set_architecture_from_file (bfd *);
1580 /* Do the real work of changing the current architecture */
1583 arch_ok (const struct bfd_arch_info *arch)
1585 /* Should be performing the more basic check that the binary is
1586 compatible with GDB. */
1587 /* Check with the target that the architecture is valid. */
1588 return (target_architecture_hook == NULL
1589 || target_architecture_hook (arch));
1593 set_arch (const struct bfd_arch_info *arch,
1599 if (!arch_ok (arch))
1600 warning ("Target may not support %s architecture",
1601 arch->printable_name);
1602 target_architecture = arch;
1604 case set_arch_manual:
1605 if (!arch_ok (arch))
1607 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1608 arch->printable_name);
1612 target_architecture_auto = 0;
1613 target_architecture = arch;
1621 /* Called if the user enters \`\`show architecture'' without an argument. */
1623 show_architecture (char *args, int from_tty)
1626 arch = TARGET_ARCHITECTURE->printable_name;
1627 if (target_architecture_auto)
1628 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1630 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1633 /* Called if the user enters \`\`set architecture'' with or without an
1636 set_architecture (char *args, int from_tty)
1640 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1642 else if (strcmp (args, "auto") == 0)
1644 target_architecture_auto = 1;
1646 else if (GDB_MULTI_ARCH)
1648 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1650 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1653 struct gdbarch_info info;
1654 memset (&info, 0, sizeof info);
1655 info.bfd_arch_info = arch;
1656 if (gdbarch_update (info))
1657 target_architecture_auto = 0;
1659 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1664 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1666 set_arch (arch, set_arch_manual);
1668 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1672 /* Called if the user enters \`\`info architecture'' without an argument. */
1674 info_architecture (char *args, int from_tty)
1676 enum bfd_architecture a;
1679 if (gdbarch_init_registrary != NULL)
1681 struct gdbarch_init_registration *rego;
1682 printf_filtered ("Available architectures are:\n");
1683 for (rego = gdbarch_init_registrary;
1687 const struct bfd_arch_info *ap;
1688 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1693 printf_filtered (" %s", ap->printable_name);
1697 printf_filtered ("\n");
1703 printf_filtered ("There are no available architectures.\n");
1707 printf_filtered ("Available architectures are:\n");
1708 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1710 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1715 printf_filtered (" %s", ap->printable_name);
1719 printf_filtered ("\n");
1724 /* Set the architecture from arch/machine */
1726 set_architecture_from_arch_mach (arch, mach)
1727 enum bfd_architecture arch;
1730 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1732 set_arch (wanted, set_arch_manual);
1734 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1737 /* Set the architecture from a BFD */
1739 set_architecture_from_file (bfd *abfd)
1741 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1742 if (target_architecture_auto)
1744 set_arch (wanted, set_arch_auto);
1746 else if (wanted != target_architecture)
1748 warning ("%s architecture file may be incompatible with %s target.",
1749 wanted->printable_name,
1750 target_architecture->printable_name);
1755 /* Misc helper functions for targets. */
1758 frame_num_args_unknown (fi)
1759 struct frame_info *fi;
1766 generic_register_convertible_not (num)
1774 /* Pointer to the target-dependent disassembly function. */
1775 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1776 disassemble_info tm_print_insn_info;
1780 /* Set the dynamic target-system-dependant parameters (architecture,
1781 byte-order) using information found in the BFD */
1784 set_gdbarch_from_file (abfd)
1789 struct gdbarch_info info;
1790 memset (&info, 0, sizeof info);
1792 gdbarch_update (info);
1795 set_architecture_from_file (abfd);
1796 set_endian_from_file (abfd);
1800 #if defined (CALL_DUMMY)
1801 /* FIXME - this should go away */
1802 LONGEST call_dummy_words[] = CALL_DUMMY;
1803 int sizeof_call_dummy_words = sizeof (call_dummy_words);
1807 extern void _initialize_gdbarch (void);
1809 _initialize_gdbarch ()
1811 add_prefix_cmd ("endian", class_support, set_endian,
1812 "Set endianness of target.",
1813 &endianlist, "set endian ", 0, &setlist);
1814 add_cmd ("big", class_support, set_endian_big,
1815 "Set target as being big endian.", &endianlist);
1816 add_cmd ("little", class_support, set_endian_little,
1817 "Set target as being little endian.", &endianlist);
1818 add_cmd ("auto", class_support, set_endian_auto,
1819 "Select target endianness automatically.", &endianlist);
1820 add_cmd ("endian", class_support, show_endian,
1821 "Show endianness of target.", &showlist);
1823 add_cmd ("architecture", class_support, set_architecture,
1824 "Set architecture of target.", &setlist);
1825 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
1826 add_cmd ("architecture", class_support, show_architecture,
1827 "Show architecture of target.", &showlist);
1828 add_cmd ("architecture", class_support, info_architecture,
1829 "List supported target architectures", &infolist);
1831 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1832 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1833 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1834 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1835 tm_print_insn_info.print_address_func = dis_asm_print_address;
1837 add_show_from_set (add_set_cmd ("archdebug",
1840 (char *)&gdbarch_debug,
1841 "Set architecture debugging.\n\\
1842 When non-zero, architecture debugging is enabled.", &setlist),
1849 #../move-if-change new-gdbarch.c gdbarch.c
1850 if ! test -r gdbarch.c
1852 echo "gdbarch.c missing? cp new-gdbarch.c gdbarch.c" 1>&2
1853 elif diff -c gdbarch.c new-gdbarch.c
1855 echo "gdbarch.c unchanged" 1>&2
1857 echo "gdbarch.c has changed? cp new-gdbarch.c gdbarch.c" 1>&2
This page took 0.095486 seconds and 4 git commands to generate.