3 # Architecture commands for GDB, the GNU debugger.
4 # Copyright 1998-2000 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.
27 echo "${file} missing? cp new-${file} ${file}" 1>&2
28 elif diff -c ${file} new-${file}
30 echo "${file} unchanged" 1>&2
32 echo "${file} has changed? cp new-${file} ${file}" 1>&2
37 # Format of the input table
38 read="class level macro returntype function formal actual attrib default init invalid_p fmt print print_p description"
40 # dump out/verify the doco
53 # hiding something from the ``struct info'' object
57 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
58 # LEVEL is a predicate on checking that a given method is
59 # initialized (using INVALID_P).
63 # The name of the MACRO that this method is to be accessed by.
67 # For functions, the return type; for variables, the data type
71 # For functions, the member function name; for variables, the
72 # variable name. Member function names are always prefixed with
73 # ``gdbarch_'' for name-space purity.
77 # The formal argument list. It is assumed that the formal
78 # argument list includes the actual name of each list element.
79 # A function with no arguments shall have ``void'' as the formal
84 # The list of actual arguments. The arguments specified shall
85 # match the FORMAL list given above. Functions with out
86 # arguments leave this blank.
90 # Any GCC attributes that should be attached to the function
91 # declaration. At present this field is unused.
95 # To help with the GDB startup a default static gdbarch object
96 # is created. DEFAULT is the value to insert into the static
97 # gdbarch object. If empty ZERO is used.
101 # Any initial value to assign to a new gdbarch object after it
102 # as been malloc()ed. Zero is used by default.
106 # A predicate equation that validates MEMBER. Non-zero is returned
107 # if the code creating the new architecture failed to initialize
108 # the MEMBER or initialized the member to something invalid.
109 # By default, a check that the value is no longer equal to INIT
110 # is performed. The equation ``0'' disables the invalid_p check.
114 # printf style format string that can be used to print out the
115 # MEMBER. The default is to assume "%ld" is safe. Sometimes
116 # "%s" is useful. For functions, this is ignored and the
117 # function address is printed.
121 # An optional equation that converts the MEMBER into a value
122 # suitable for that FMT. By default it is assumed that the
123 # member's MACRO cast to long is safe.
127 # An optional indicator for any predicte to wrap around the
129 # # -> Wrap print up in ``#ifdef MACRO''
130 # exp -> Wrap print up in ``if (${print_p}) ...
144 # See below (DOCO) for description of each field
146 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct:::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
148 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
150 v:1:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address:0
151 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
152 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
153 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
154 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
155 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
156 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
157 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
158 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
159 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
161 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
162 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
163 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
164 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
165 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
166 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
168 v:2:NUM_REGS:int:num_regs::::0:-1
169 v:2:SP_REGNUM:int:sp_regnum::::0:-1
170 v:2:FP_REGNUM:int:fp_regnum::::0:-1
171 v:2:PC_REGNUM:int:pc_regnum::::0:-1
172 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr::0:0
173 v:2:REGISTER_SIZE:int:register_size::::0:-1
174 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
175 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
176 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
177 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
178 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
179 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
180 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
182 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
183 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
184 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:
185 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1::0x%08lx
186 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::0x%08lx
187 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
188 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
189 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
190 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
191 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:::0x%08lx
192 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:::0x%08lx
193 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1::0x%08lx
194 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
195 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
197 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::0:::::#
198 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::0:::::#
199 f:2:COERCE_FLOAT_TO_DOUBLE:int:coerce_float_to_double:struct type *formal, struct type *actual:formal, actual:::default_coerce_float_to_double
200 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
202 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr::0:0
203 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
204 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
206 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
207 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
208 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-::0:0
209 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp::0:0
210 f:2:POP_FRAME:void:pop_frame:void:-::0:0
212 # I wish that these would just go away....
213 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x::0:0
214 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x::0:0
215 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x::0:0
216 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x::0:0
217 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x::0:0
218 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x::0:0
220 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp::0:0
221 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf::0:0
222 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf::0:0
223 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type::0:0
225 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
226 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame::0:0
228 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
229 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
230 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:0
231 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint:0
232 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint:0
233 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
234 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
236 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
238 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
239 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi::0:0
240 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
241 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
242 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
243 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
244 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
245 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
246 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
257 function_list | while eval read $read
260 ${class} ${macro}(${actual})
261 ${returntype} ${function} ($formal)${attrib}
265 invalid_p=${invalid_p}
269 description=${description}
278 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
280 /* Dynamic architecture support for GDB, the GNU debugger.
281 Copyright 1998-1999, Free Software Foundation, Inc.
283 This file is part of GDB.
285 This program is free software; you can redistribute it and/or modify
286 it under the terms of the GNU General Public License as published by
287 the Free Software Foundation; either version 2 of the License, or
288 (at your option) any later version.
290 This program is distributed in the hope that it will be useful,
291 but WITHOUT ANY WARRANTY; without even the implied warranty of
292 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
293 GNU General Public License for more details.
295 You should have received a copy of the GNU General Public License
296 along with this program; if not, write to the Free Software
297 Foundation, Inc., 59 Temple Place - Suite 330,
298 Boston, MA 02111-1307, USA. */
300 /* This file was created with the aid of \`\`gdbarch.sh''.
302 The bourn shell script \`\`gdbarch.sh'' creates the files
303 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
304 against the existing \`\`gdbarch.[hc]''. Any differences found
307 If editing this file, please also run gdbarch.sh and merge any
308 changes into that script. Conversely, when makeing sweeping changes
309 to this file, modifying gdbarch.sh and using its output may prove
329 #ifndef GDB_MULTI_ARCH
330 #define GDB_MULTI_ARCH 0
333 extern struct gdbarch *current_gdbarch;
336 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
340 /* If any of the following are defined, the target wasn't correctly
344 #if defined (CALL_DUMMY)
345 #error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
350 #if defined (REGISTER_NAMES)
351 #error "REGISTER_NAMES: replaced by REGISTER_NAME"
356 #if defined (EXTRA_FRAME_INFO)
357 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
362 #if defined (FRAME_FIND_SAVED_REGS)
363 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
371 echo "/* The following are pre-initialized by GDBARCH. */"
372 function_list | while eval read $read
377 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
378 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
379 echo "#if GDB_MULTI_ARCH"
380 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
381 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
391 echo "/* The following are initialized by the target dependant code. */"
392 function_list | while eval read $read
397 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
398 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
399 echo "#if GDB_MULTI_ARCH"
400 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
401 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
407 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
408 if [ "${formal}" = "void" ]
410 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
412 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
414 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
415 echo "#if GDB_MULTI_ARCH"
416 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
417 if [ "${actual}" = "" ]
419 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
420 elif [ "${actual}" = "-" ]
422 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
424 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
435 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
438 /* Mechanism for co-ordinating the selection of a specific
441 GDB targets (*-tdep.c) can register an interest in a specific
442 architecture. Other GDB components can register a need to maintain
443 per-architecture data.
445 The mechanisms below ensures that there is only a loose connection
446 between the set-architecture command and the various GDB
447 components. Each component can independantly register their need
448 to maintain architecture specific data with gdbarch.
452 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
455 The more traditional mega-struct containing architecture specific
456 data for all the various GDB components was also considered. Since
457 GDB is built from a variable number of (fairly independant)
458 components it was determined that the global aproach was not
462 /* Register a new architectural family with GDB.
464 Register support for the specified ARCHITECTURE with GDB. When
465 gdbarch determines that the specified architecture has been
466 selected, the corresponding INIT function is called.
470 The INIT function takes two parameters: INFO which contains the
471 information available to gdbarch about the (possibly new)
472 architecture; ARCHES which is a list of the previously created
473 \`\`struct gdbarch'' for this architecture.
475 The INIT function parameter INFO shall, as far as possible, be
476 pre-initialized with information obtained from INFO.ABFD or
477 previously selected architecture (if similar). INIT shall ensure
478 that the INFO.BYTE_ORDER is non-zero.
480 The INIT function shall return any of: NULL - indicating that it
481 doesn't reconize the selected architecture; an existing \`\`struct
482 gdbarch'' from the ARCHES list - indicating that the new
483 architecture is just a synonym for an earlier architecture (see
484 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
485 - that describes the selected architecture (see
490 struct gdbarch *gdbarch;
491 struct gdbarch_list *next;
496 /* Use default: bfd_arch_unknown (ZERO). */
497 enum bfd_architecture bfd_architecture;
499 /* Use default: NULL (ZERO). */
500 const struct bfd_arch_info *bfd_arch_info;
502 /* Use default: 0 (ZERO). */
505 /* Use default: NULL (ZERO). */
508 /* Use default: NULL (ZERO). */
509 struct gdbarch_tdep_info *tdep_info;
512 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
514 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
517 /* Helper function. Search the list of ARCHES for a GDBARCH that
518 matches the information provided by INFO. */
520 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
523 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
524 basic initialization using values obtained from the INFO andTDEP
525 parameters. set_gdbarch_*() functions are called to complete the
526 initialization of the object. */
528 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
531 /* Helper function. Free a partially-constructed \`\`struct gdbarch''. */
532 extern void gdbarch_free (struct gdbarch *);
535 /* Helper function. Force an update of the current architecture. Used
536 by legacy targets that have added their own target specific
537 architecture manipulation commands.
539 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
540 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
541 called. gdbarch_update() shall initialize any \`\`default'' fields
542 using information obtained from the previous architecture or
543 INFO.ABFD (if specified) before calling the corresponding
544 architectures INIT function. */
546 extern int gdbarch_update (struct gdbarch_info info);
550 /* Register per-architecture data-pointer.
552 Reserve space for a per-architecture data-pointer. An identifier
553 for the reserved data-pointer is returned. That identifer should
554 be saved in a local static.
556 When a new architecture is selected, INIT() is called. When a
557 previous architecture is re-selected, the per-architecture
558 data-pointer for that previous architecture is restored (INIT() is
561 INIT() shall return the initial value for the per-architecture
562 data-pointer for the current architecture.
564 Multiple registrarants for any architecture are allowed (and
565 strongly encouraged). */
567 typedef void *(gdbarch_data_ftype) (void);
568 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
570 /* Return the value of the per-architecture data-pointer for the
571 current architecture. */
573 extern void *gdbarch_data (struct gdbarch_data*);
577 /* Register per-architecture memory region.
579 Provide a memory-region swap mechanism. Per-architecture memory
580 region are created. These memory regions are swapped whenever the
581 architecture is changed. For a new architecture, the memory region
582 is initialized with zero (0) and the INIT function is called.
584 Memory regions are swapped / initialized in the order that they are
585 registered. NULL DATA and/or INIT values can be specified.
587 New code should use register_gdbarch_data(). */
589 typedef void (gdbarch_swap_ftype) (void);
590 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
591 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
595 /* The target-system-dependant byte order is dynamic */
597 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
598 is selectable at runtime. The user can use the \`\`set endian''
599 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
600 target_byte_order should be auto-detected (from the program image
604 /* Multi-arch GDB is always bi-endian. */
605 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
608 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
609 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
610 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
611 #ifdef TARGET_BYTE_ORDER_SELECTABLE
612 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
614 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
618 extern int target_byte_order;
619 #ifdef TARGET_BYTE_ORDER_SELECTABLE
620 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
621 and expect defs.h to re-define TARGET_BYTE_ORDER. */
622 #undef TARGET_BYTE_ORDER
624 #ifndef TARGET_BYTE_ORDER
625 #define TARGET_BYTE_ORDER (target_byte_order + 0)
628 extern int target_byte_order_auto;
629 #ifndef TARGET_BYTE_ORDER_AUTO
630 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
635 /* The target-system-dependant BFD architecture is dynamic */
637 extern int target_architecture_auto;
638 #ifndef TARGET_ARCHITECTURE_AUTO
639 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
642 extern const struct bfd_arch_info *target_architecture;
643 #ifndef TARGET_ARCHITECTURE
644 #define TARGET_ARCHITECTURE (target_architecture + 0)
647 /* Notify the target dependant backend of a change to the selected
648 architecture. A zero return status indicates that the target did
649 not like the change. */
651 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
655 /* The target-system-dependant disassembler is semi-dynamic */
657 #include "dis-asm.h" /* Get defs for disassemble_info */
659 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
660 unsigned int len, disassemble_info *info);
662 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
663 disassemble_info *info);
665 extern void dis_asm_print_address (bfd_vma addr,
666 disassemble_info *info);
668 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
669 extern disassemble_info tm_print_insn_info;
670 #ifndef TARGET_PRINT_INSN
671 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
673 #ifndef TARGET_PRINT_INSN_INFO
674 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
679 /* Explicit test for D10V architecture.
680 USE of these macro's is *STRONGLY* discouraged. */
682 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
683 #ifndef D10V_MAKE_DADDR
684 #define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
686 #ifndef D10V_MAKE_IADDR
687 #define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
691 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
692 #ifndef FRAMELESS_FUNCTION_INVOCATION
693 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
697 /* Fallback definition of REGISTER_CONVERTIBLE etc */
698 extern int generic_register_convertible_not (int reg_nr);
699 #ifndef REGISTER_CONVERTIBLE
700 #define REGISTER_CONVERTIBLE(x) (0)
702 #ifndef REGISTER_CONVERT_TO_VIRTUAL
703 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
705 #ifndef REGISTER_CONVERT_TO_RAW
706 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
710 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
711 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
712 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
713 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
715 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
716 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
721 /* Fallback definition for REGISTER_NAME for systems still defining
723 #ifndef REGISTER_NAME
724 extern char *gdb_register_names[];
725 #define REGISTER_NAME(i) gdb_register_names[i]
729 /* Set the dynamic target-system-dependant parameters (architecture,
730 byte-order, ...) using information found in the BFD */
732 extern void set_gdbarch_from_file (bfd *);
735 /* Explicitly set the dynamic target-system-dependant parameters based
736 on bfd_architecture and machine. */
738 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
741 /* Initialize the current architecture to the "first" one we find on
744 extern void initialize_current_architecture (void);
746 /* Helper function for targets that don't know how my arguments are
749 extern int frame_num_args_unknown (struct frame_info *fi);
752 /* gdbarch trace variable */
753 extern int gdbarch_debug;
755 extern void gdbarch_dump (void);
760 #../move-if-change new-gdbarch.h gdbarch.h
761 compare_new gdbarch.h
776 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
778 /* Just include everything in sight so that the every old definition
779 of macro is visible. */
780 #include "gdb_string.h"
784 #include "inferior.h"
785 #include "breakpoint.h"
786 #include "gdb_wait.h"
790 #include "gdbthread.h"
791 #include "annotate.h"
792 #include "symfile.h" /* for overlay functions */
797 /* Static function declarations */
799 static void verify_gdbarch (struct gdbarch *gdbarch);
800 static void init_gdbarch_data (struct gdbarch *);
801 static void init_gdbarch_swap (struct gdbarch *);
802 static void swapout_gdbarch_swap (struct gdbarch *);
803 static void swapin_gdbarch_swap (struct gdbarch *);
805 /* Convenience macro for allocting typesafe memory. */
808 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
812 /* Non-zero if we want to trace architecture code. */
814 #ifndef GDBARCH_DEBUG
815 #define GDBARCH_DEBUG 0
817 int gdbarch_debug = GDBARCH_DEBUG;
821 # gdbarch open the gdbarch object
823 echo "/* Maintain the struct gdbarch object */"
825 echo "struct gdbarch"
827 echo " /* basic architectural information */"
828 function_list | while eval read $read
831 "i" ) echo " ${returntype} ${function};" ;;
835 echo " /* target specific vector. */"
836 echo " struct gdbarch_tdep *tdep;"
838 echo " /* per-architecture data-pointers */"
842 echo " /* per-architecture swap-regions */"
843 echo " struct gdbarch_swap *swap;"
846 /* Multi-arch values.
848 When extending this structure you must:
852 Declare set/get functions and define the corresponding
855 gdbarch_alloc(): If zero/NULL is not a suitable default,
856 initialize the new field.
858 verify_gdbarch(): Confirm that the target updated the field
861 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
864 \`\`default_gdbarch()'': Append an initial value to the static
865 variable (base values on the host's c-type system).
867 get_gdbarch(): Implement the set/get functions (probably using
868 the macro's as shortcuts).
873 function_list | while eval read $read
876 "v" ) echo " ${returntype} ${function};" ;;
877 "f" ) echo " gdbarch_${function}_ftype *${function}${attrib};" ;;
882 # A pre-initialized vector
886 /* The default architecture uses host values (for want of a better
890 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
892 echo "struct gdbarch default_gdbarch = {"
893 echo " /* basic architecture information */"
894 function_list | while eval read $read
898 if [ "${default}" = "" ]; then
907 /* target specific vector */
909 /*per-architecture data-pointers and swap regions */
911 /* Multi-arch values */
913 function_list | while eval read $read
917 if [ "${default}" = "" ]; then
926 /* default_gdbarch() */
928 struct gdbarch *current_gdbarch = &default_gdbarch;
931 # Create a new gdbarch struct
935 /* Create a new \`\`struct gdbarch'' based in information provided by
936 \`\`struct gdbarch_info''. */
941 gdbarch_alloc (const struct gdbarch_info *info,
942 struct gdbarch_tdep *tdep)
944 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
945 memset (gdbarch, 0, sizeof (*gdbarch));
947 gdbarch->tdep = tdep;
950 function_list | while eval read $read
953 "i" ) echo " gdbarch->${function} = info->${function};"
957 echo " /* Force the explicit initialization of these. */"
958 function_list | while eval read $read
962 if [ "${init}" != "" -a "${init}" != "0" ]
964 echo " gdbarch->${function} = ${init};"
970 /* gdbarch_alloc() */
976 # Free a gdbarch struct.
980 /* Free a gdbarch struct. This should never happen in normal
981 operation --- once you've created a gdbarch, you keep it around.
982 However, if an architecture's init function encounters an error
983 building the structure, it may need to clean up a partially
984 constructed gdbarch. */
986 gdbarch_free (struct gdbarch *arch)
988 /* At the moment, this is trivial. */
993 # verify a new architecture
996 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1000 verify_gdbarch (struct gdbarch *gdbarch)
1002 /* Only perform sanity checks on a multi-arch target. */
1003 if (GDB_MULTI_ARCH <= 0)
1006 if (gdbarch->byte_order == 0)
1007 internal_error ("verify_gdbarch: byte-order unset");
1008 if (gdbarch->bfd_arch_info == NULL)
1009 internal_error ("verify_gdbarch: bfd_arch_info unset");
1010 /* Check those that need to be defined for the given multi-arch level. */
1012 function_list | while eval read $read
1016 if [ "${invalid_p}" ]
1018 echo " if ((GDB_MULTI_ARCH >= ${level})"
1019 echo " && (${invalid_p}))"
1020 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1023 echo " if ((GDB_MULTI_ARCH >= ${level})"
1024 echo " && (gdbarch->${function} == ${init}))"
1025 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1034 # dump the structure
1037 echo "/* Print out the details of the current architecture. */"
1044 function_list | while eval read $read
1048 echo " fprintf_unfiltered (gdb_stdlog,"
1049 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1050 echo " (long) current_gdbarch->${function}"
1051 echo " /*${macro} ()*/);"
1054 test "${fmt}" || fmt="%ld"
1055 test "${print}" || print="(long) ${macro}"
1056 if [ "${print_p}" = "#" ]
1058 echo "#ifdef ${macro}"
1059 echo " fprintf_unfiltered (gdb_stdlog,"
1060 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1063 elif [ "${print_p}" ]
1065 echo " if (${print_p})"
1066 echo " fprintf_unfiltered (gdb_stdlog,"
1067 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1070 echo " fprintf_unfiltered (gdb_stdlog,"
1071 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1083 struct gdbarch_tdep *
1084 gdbarch_tdep (struct gdbarch *gdbarch)
1086 if (gdbarch_debug >= 2)
1087 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1088 return gdbarch->tdep;
1092 function_list | while eval read $read
1097 echo "${returntype}"
1098 if [ "${formal}" = "void" ]
1100 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1102 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1105 echo " if (gdbarch->${function} == 0)"
1106 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1107 echo " if (gdbarch_debug >= 2)"
1108 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1109 test "${actual}" = "-" && actual=""
1110 if [ "${returntype}" = "void" ]
1112 echo " gdbarch->${function} (${actual});"
1114 echo " return gdbarch->${function} (${actual});"
1119 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1120 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1122 echo " gdbarch->${function} = ${function};"
1127 echo "${returntype}"
1128 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1130 if [ "${invalid_p}" ]
1132 echo " if (${invalid_p})"
1133 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1136 echo " if (gdbarch->${function} == ${init})"
1137 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1139 echo " if (gdbarch_debug >= 2)"
1140 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1141 echo " return gdbarch->${function};"
1145 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1146 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1148 echo " gdbarch->${function} = ${function};"
1153 echo "${returntype}"
1154 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1156 echo " if (gdbarch_debug >= 2)"
1157 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1158 echo " return gdbarch->${function};"
1164 # All the trailing guff
1168 /* Keep a registrary of per-architecture data-pointers required by GDB
1176 struct gdbarch_data_registration
1178 gdbarch_data_ftype *init;
1179 struct gdbarch_data *data;
1180 struct gdbarch_data_registration *next;
1183 struct gdbarch_data_registrary
1186 struct gdbarch_data_registration *registrations;
1189 struct gdbarch_data_registrary gdbarch_data_registrary =
1194 struct gdbarch_data *
1195 register_gdbarch_data (gdbarch_data_ftype *init)
1197 struct gdbarch_data_registration **curr;
1198 for (curr = &gdbarch_data_registrary.registrations;
1200 curr = &(*curr)->next);
1201 (*curr) = XMALLOC (struct gdbarch_data_registration);
1202 (*curr)->next = NULL;
1203 (*curr)->init = init;
1204 (*curr)->data = XMALLOC (struct gdbarch_data);
1205 (*curr)->data->index = gdbarch_data_registrary.nr++;
1206 return (*curr)->data;
1210 /* Walk through all the registered users initializing each in turn. */
1213 init_gdbarch_data (struct gdbarch *gdbarch)
1215 struct gdbarch_data_registration *rego;
1216 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1217 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1218 for (rego = gdbarch_data_registrary.registrations;
1222 if (rego->data->index < gdbarch->nr_data)
1223 gdbarch->data[rego->data->index] = rego->init ();
1228 /* Return the current value of the specified per-architecture
1233 struct gdbarch_data *data;
1235 if (data->index >= current_gdbarch->nr_data)
1236 internal_error ("gdbarch_data: request for non-existant data.");
1237 return current_gdbarch->data[data->index];
1242 /* Keep a registrary of swaped data required by GDB modules. */
1247 struct gdbarch_swap_registration *source;
1248 struct gdbarch_swap *next;
1251 struct gdbarch_swap_registration
1254 unsigned long sizeof_data;
1255 gdbarch_swap_ftype *init;
1256 struct gdbarch_swap_registration *next;
1259 struct gdbarch_swap_registrary
1262 struct gdbarch_swap_registration *registrations;
1265 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1271 register_gdbarch_swap (void *data,
1272 unsigned long sizeof_data,
1273 gdbarch_swap_ftype *init)
1275 struct gdbarch_swap_registration **rego;
1276 for (rego = &gdbarch_swap_registrary.registrations;
1278 rego = &(*rego)->next);
1279 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1280 (*rego)->next = NULL;
1281 (*rego)->init = init;
1282 (*rego)->data = data;
1283 (*rego)->sizeof_data = sizeof_data;
1288 init_gdbarch_swap (struct gdbarch *gdbarch)
1290 struct gdbarch_swap_registration *rego;
1291 struct gdbarch_swap **curr = &gdbarch->swap;
1292 for (rego = gdbarch_swap_registrary.registrations;
1296 if (rego->data != NULL)
1298 (*curr) = XMALLOC (struct gdbarch_swap);
1299 (*curr)->source = rego;
1300 (*curr)->swap = xmalloc (rego->sizeof_data);
1301 (*curr)->next = NULL;
1302 memset (rego->data, 0, rego->sizeof_data);
1303 curr = &(*curr)->next;
1305 if (rego->init != NULL)
1311 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1313 struct gdbarch_swap *curr;
1314 for (curr = gdbarch->swap;
1317 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1321 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1323 struct gdbarch_swap *curr;
1324 for (curr = gdbarch->swap;
1327 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1331 /* Keep a registrary of the architectures known by GDB. */
1333 struct gdbarch_init_registration
1335 enum bfd_architecture bfd_architecture;
1336 gdbarch_init_ftype *init;
1337 struct gdbarch_list *arches;
1338 struct gdbarch_init_registration *next;
1341 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1344 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1345 gdbarch_init_ftype *init)
1347 struct gdbarch_init_registration **curr;
1348 const struct bfd_arch_info *bfd_arch_info;
1349 /* Check that BFD reconizes this architecture */
1350 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1351 if (bfd_arch_info == NULL)
1353 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1355 /* Check that we haven't seen this architecture before */
1356 for (curr = &gdbarch_init_registrary;
1358 curr = &(*curr)->next)
1360 if (bfd_architecture == (*curr)->bfd_architecture)
1361 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1362 bfd_arch_info->printable_name);
1366 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1367 bfd_arch_info->printable_name,
1370 (*curr) = XMALLOC (struct gdbarch_init_registration);
1371 (*curr)->bfd_architecture = bfd_architecture;
1372 (*curr)->init = init;
1373 (*curr)->arches = NULL;
1374 (*curr)->next = NULL;
1379 /* Look for an architecture using gdbarch_info. Base search on only
1380 BFD_ARCH_INFO and BYTE_ORDER. */
1382 struct gdbarch_list *
1383 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1384 const struct gdbarch_info *info)
1386 for (; arches != NULL; arches = arches->next)
1388 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1390 if (info->byte_order != arches->gdbarch->byte_order)
1398 /* Update the current architecture. Return ZERO if the update request
1402 gdbarch_update (struct gdbarch_info info)
1404 struct gdbarch *new_gdbarch;
1405 struct gdbarch_list **list;
1406 struct gdbarch_init_registration *rego;
1408 /* Fill in any missing bits. Most important is the bfd_architecture
1409 which is used to select the target architecture. */
1410 if (info.bfd_architecture == bfd_arch_unknown)
1412 if (info.bfd_arch_info != NULL)
1413 info.bfd_architecture = info.bfd_arch_info->arch;
1414 else if (info.abfd != NULL)
1415 info.bfd_architecture = bfd_get_arch (info.abfd);
1416 /* FIXME - should query BFD for its default architecture. */
1418 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1420 if (info.bfd_arch_info == NULL)
1422 if (target_architecture_auto && info.abfd != NULL)
1423 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1425 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1427 if (info.byte_order == 0)
1429 if (target_byte_order_auto && info.abfd != NULL)
1430 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1431 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1434 info.byte_order = current_gdbarch->byte_order;
1435 /* FIXME - should query BFD for its default byte-order. */
1437 /* A default for abfd? */
1439 /* Find the target that knows about this architecture. */
1440 for (rego = gdbarch_init_registrary;
1441 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1446 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1452 fprintf_unfiltered (gdb_stdlog,
1453 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1454 info.bfd_architecture,
1455 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1456 fprintf_unfiltered (gdb_stdlog,
1457 "gdbarch_update: info.bfd_arch_info %s\n",
1458 (info.bfd_arch_info != NULL
1459 ? info.bfd_arch_info->printable_name
1461 fprintf_unfiltered (gdb_stdlog,
1462 "gdbarch_update: info.byte_order %d (%s)\n",
1464 (info.byte_order == BIG_ENDIAN ? "big"
1465 : info.byte_order == LITTLE_ENDIAN ? "little"
1467 fprintf_unfiltered (gdb_stdlog,
1468 "gdbarch_update: info.abfd 0x%lx\n",
1470 fprintf_unfiltered (gdb_stdlog,
1471 "gdbarch_update: info.tdep_info 0x%lx\n",
1472 (long) info.tdep_info);
1475 /* Ask the target for a replacement architecture. */
1476 new_gdbarch = rego->init (info, rego->arches);
1478 /* Did the target like it? No. Reject the change. */
1479 if (new_gdbarch == NULL)
1482 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1486 /* Did the architecture change? No. Do nothing. */
1487 if (current_gdbarch == new_gdbarch)
1490 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1492 new_gdbarch->bfd_arch_info->printable_name);
1496 /* Swap all data belonging to the old target out */
1497 swapout_gdbarch_swap (current_gdbarch);
1499 /* Is this a pre-existing architecture? Yes. Swap it in. */
1500 for (list = ®o->arches;
1502 list = &(*list)->next)
1504 if ((*list)->gdbarch == new_gdbarch)
1507 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1509 new_gdbarch->bfd_arch_info->printable_name);
1510 current_gdbarch = new_gdbarch;
1511 swapin_gdbarch_swap (new_gdbarch);
1516 /* Append this new architecture to this targets list. */
1517 (*list) = XMALLOC (struct gdbarch_list);
1518 (*list)->next = NULL;
1519 (*list)->gdbarch = new_gdbarch;
1521 /* Switch to this new architecture. Dump it out. */
1522 current_gdbarch = new_gdbarch;
1525 fprintf_unfiltered (gdb_stdlog,
1526 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1528 new_gdbarch->bfd_arch_info->printable_name);
1532 /* Check that the newly installed architecture is valid. */
1533 verify_gdbarch (new_gdbarch);
1535 /* Initialize the per-architecture memory (swap) areas.
1536 CURRENT_GDBARCH must be update before these modules are
1538 init_gdbarch_swap (new_gdbarch);
1540 /* Initialize the per-architecture data-pointer of all parties that
1541 registered an interest in this architecture. CURRENT_GDBARCH
1542 must be updated before these modules are called. */
1543 init_gdbarch_data (new_gdbarch);
1550 /* Functions to manipulate the endianness of the target. */
1552 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1553 /* compat - Catch old targets that expect a selectable byte-order to
1554 default to BIG_ENDIAN */
1555 #ifndef TARGET_BYTE_ORDER_DEFAULT
1556 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1559 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1560 #ifndef TARGET_BYTE_ORDER_DEFAULT
1561 /* compat - Catch old non byte-order selectable targets that do not
1562 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1563 TARGET_BYTE_ORDER to be used as the default. For targets that
1564 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1565 below will get a strange compiler warning. */
1566 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1569 #ifndef TARGET_BYTE_ORDER_DEFAULT
1570 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1572 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1573 int target_byte_order_auto = 1;
1575 /* Chain containing the \"set endian\" commands. */
1576 static struct cmd_list_element *endianlist = NULL;
1578 /* Called by \`\`show endian''. */
1580 show_endian (char *args, int from_tty)
1583 (TARGET_BYTE_ORDER_AUTO
1584 ? "The target endianness is set automatically (currently %s endian)\n"
1585 : "The target is assumed to be %s endian\n");
1586 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1589 /* Called if the user enters \`\`set endian'' without an argument. */
1591 set_endian (char *args, int from_tty)
1593 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1594 show_endian (args, from_tty);
1597 /* Called by \`\`set endian big''. */
1599 set_endian_big (char *args, int from_tty)
1601 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1603 target_byte_order = BIG_ENDIAN;
1604 target_byte_order_auto = 0;
1607 struct gdbarch_info info;
1608 memset (&info, 0, sizeof info);
1609 info.byte_order = BIG_ENDIAN;
1610 gdbarch_update (info);
1615 printf_unfiltered ("Byte order is not selectable.");
1616 show_endian (args, from_tty);
1620 /* Called by \`\`set endian little''. */
1622 set_endian_little (char *args, int from_tty)
1624 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1626 target_byte_order = LITTLE_ENDIAN;
1627 target_byte_order_auto = 0;
1630 struct gdbarch_info info;
1631 memset (&info, 0, sizeof info);
1632 info.byte_order = LITTLE_ENDIAN;
1633 gdbarch_update (info);
1638 printf_unfiltered ("Byte order is not selectable.");
1639 show_endian (args, from_tty);
1643 /* Called by \`\`set endian auto''. */
1645 set_endian_auto (char *args, int from_tty)
1647 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1649 target_byte_order_auto = 1;
1653 printf_unfiltered ("Byte order is not selectable.");
1654 show_endian (args, from_tty);
1658 /* Set the endianness from a BFD. */
1660 set_endian_from_file (bfd *abfd)
1662 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1666 if (bfd_big_endian (abfd))
1669 want = LITTLE_ENDIAN;
1670 if (TARGET_BYTE_ORDER_AUTO)
1671 target_byte_order = want;
1672 else if (TARGET_BYTE_ORDER != want)
1673 warning ("%s endian file does not match %s endian target.",
1674 want == BIG_ENDIAN ? "big" : "little",
1675 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1679 if (bfd_big_endian (abfd)
1680 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1681 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1682 warning ("%s endian file does not match %s endian target.",
1683 bfd_big_endian (abfd) ? "big" : "little",
1684 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1690 /* Functions to manipulate the architecture of the target */
1692 enum set_arch { set_arch_auto, set_arch_manual };
1694 int target_architecture_auto = 1;
1695 extern const struct bfd_arch_info bfd_default_arch_struct;
1696 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1697 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1699 static void show_endian (char *, int);
1700 static void set_endian (char *, int);
1701 static void set_endian_big (char *, int);
1702 static void set_endian_little (char *, int);
1703 static void set_endian_auto (char *, int);
1704 static void set_endian_from_file (bfd *);
1705 static int arch_ok (const struct bfd_arch_info *arch);
1706 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1707 static void show_architecture (char *, int);
1708 static void set_architecture (char *, int);
1709 static void info_architecture (char *, int);
1710 static void set_architecture_from_file (bfd *);
1712 /* Do the real work of changing the current architecture */
1715 arch_ok (const struct bfd_arch_info *arch)
1717 /* Should be performing the more basic check that the binary is
1718 compatible with GDB. */
1719 /* Check with the target that the architecture is valid. */
1720 return (target_architecture_hook == NULL
1721 || target_architecture_hook (arch));
1725 set_arch (const struct bfd_arch_info *arch,
1731 if (!arch_ok (arch))
1732 warning ("Target may not support %s architecture",
1733 arch->printable_name);
1734 target_architecture = arch;
1736 case set_arch_manual:
1737 if (!arch_ok (arch))
1739 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1740 arch->printable_name);
1744 target_architecture_auto = 0;
1745 target_architecture = arch;
1753 /* Called if the user enters \`\`show architecture'' without an argument. */
1755 show_architecture (char *args, int from_tty)
1758 arch = TARGET_ARCHITECTURE->printable_name;
1759 if (target_architecture_auto)
1760 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1762 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1765 /* Called if the user enters \`\`set architecture'' with or without an
1768 set_architecture (char *args, int from_tty)
1772 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1774 else if (strcmp (args, "auto") == 0)
1776 target_architecture_auto = 1;
1778 else if (GDB_MULTI_ARCH)
1780 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1782 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1785 struct gdbarch_info info;
1786 memset (&info, 0, sizeof info);
1787 info.bfd_arch_info = arch;
1788 if (gdbarch_update (info))
1789 target_architecture_auto = 0;
1791 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1796 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1798 set_arch (arch, set_arch_manual);
1800 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1804 /* Called if the user enters \`\`info architecture'' without an argument. */
1806 info_architecture (char *args, int from_tty)
1808 enum bfd_architecture a;
1811 if (gdbarch_init_registrary != NULL)
1813 struct gdbarch_init_registration *rego;
1814 printf_filtered ("Available architectures are:\n");
1815 for (rego = gdbarch_init_registrary;
1819 const struct bfd_arch_info *ap;
1820 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1825 printf_filtered (" %s", ap->printable_name);
1829 printf_filtered ("\n");
1835 printf_filtered ("There are no available architectures.\n");
1839 printf_filtered ("Available architectures are:\n");
1840 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1842 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1847 printf_filtered (" %s", ap->printable_name);
1851 printf_filtered ("\n");
1856 /* Set the architecture from arch/machine */
1858 set_architecture_from_arch_mach (arch, mach)
1859 enum bfd_architecture arch;
1862 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1864 set_arch (wanted, set_arch_manual);
1866 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1869 /* Set the architecture from a BFD */
1871 set_architecture_from_file (bfd *abfd)
1873 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1874 if (target_architecture_auto)
1876 set_arch (wanted, set_arch_auto);
1878 else if (wanted != target_architecture)
1880 warning ("%s architecture file may be incompatible with %s target.",
1881 wanted->printable_name,
1882 target_architecture->printable_name);
1887 /* Misc helper functions for targets. */
1890 frame_num_args_unknown (fi)
1891 struct frame_info *fi;
1898 generic_register_convertible_not (num)
1906 /* Pointer to the target-dependent disassembly function. */
1907 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1908 disassemble_info tm_print_insn_info;
1912 /* Set the dynamic target-system-dependant parameters (architecture,
1913 byte-order) using information found in the BFD */
1916 set_gdbarch_from_file (abfd)
1921 struct gdbarch_info info;
1922 memset (&info, 0, sizeof info);
1924 gdbarch_update (info);
1927 set_architecture_from_file (abfd);
1928 set_endian_from_file (abfd);
1932 #if defined (CALL_DUMMY)
1933 /* FIXME - this should go away */
1934 LONGEST call_dummy_words[] = CALL_DUMMY;
1935 int sizeof_call_dummy_words = sizeof (call_dummy_words);
1939 /* Initialize the current architecture. */
1941 initialize_current_architecture ()
1945 struct gdbarch_init_registration *rego;
1946 const struct bfd_arch_info *chosen = NULL;
1947 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
1949 const struct bfd_arch_info *ap
1950 = bfd_lookup_arch (rego->bfd_architecture, 0);
1952 /* Choose the first architecture alphabetically. */
1954 || strcmp (ap->printable_name, chosen->printable_name) < 0)
1960 struct gdbarch_info info;
1961 memset (&info, 0, sizeof info);
1962 info.bfd_arch_info = chosen;
1963 gdbarch_update (info);
1968 extern void _initialize_gdbarch (void);
1970 _initialize_gdbarch ()
1972 struct cmd_list_element *c;
1974 add_prefix_cmd ("endian", class_support, set_endian,
1975 "Set endianness of target.",
1976 &endianlist, "set endian ", 0, &setlist);
1977 add_cmd ("big", class_support, set_endian_big,
1978 "Set target as being big endian.", &endianlist);
1979 add_cmd ("little", class_support, set_endian_little,
1980 "Set target as being little endian.", &endianlist);
1981 add_cmd ("auto", class_support, set_endian_auto,
1982 "Select target endianness automatically.", &endianlist);
1983 add_cmd ("endian", class_support, show_endian,
1984 "Show endianness of target.", &showlist);
1986 add_cmd ("architecture", class_support, set_architecture,
1987 "Set architecture of target.", &setlist);
1988 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
1989 add_cmd ("architecture", class_support, show_architecture,
1990 "Show architecture of target.", &showlist);
1991 add_cmd ("architecture", class_support, info_architecture,
1992 "List supported target architectures", &infolist);
1994 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1995 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1996 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1997 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1998 tm_print_insn_info.print_address_func = dis_asm_print_address;
2000 add_show_from_set (add_set_cmd ("arch",
2003 (char *)&gdbarch_debug,
2004 "Set architecture debugging.\n\\
2005 When non-zero, architecture debugging is enabled.", &setdebuglist),
2007 c = add_set_cmd ("archdebug",
2010 (char *)&gdbarch_debug,
2011 "Set architecture debugging.\n\\
2012 When non-zero, architecture debugging is enabled.", &setlist);
2014 deprecate_cmd (c, "set debug arch");
2015 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2021 #../move-if-change new-gdbarch.c gdbarch.c
2022 compare_new gdbarch.c