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.
22 read="class level macro returntype function formal actual attrib default init invalid_p fmt print print_p description"
24 # dump out/verify the doco
37 # hiding something from the ``struct info'' object
41 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
42 # LEVEL is a predicate on checking that a given method is
43 # initialized (using INVALID_P).
47 # The name of the MACRO that this method is to be accessed by.
51 # For functions, the return type; for variables, the data type
55 # For functions, the member function name; for variables, the
56 # variable name. Member function names are always prefixed with
57 # ``gdbarch_'' for name-space purity.
61 # The formal argument list. It is assumed that the formal
62 # argument list includes the actual name of each list element.
63 # A function with no arguments shall have ``void'' as the formal
68 # The list of actual arguments. The arguments specified shall
69 # match the FORMAL list given above. Functions with out
70 # arguments leave this blank.
74 # Any GCC attributes that should be attached to the function
75 # declaration. At present this field is unused.
79 # To help with the GDB startup a default static gdbarch object
80 # is created. DEFAULT is the value to insert into the static
81 # gdbarch object. If empty ZERO is used.
85 # Any initial value to assign to a new gdbarch object after it
86 # as been malloc()ed. Zero is used by default.
90 # A predicate equation that validates MEMBER. Non-zero is returned
91 # if the code creating the new architecture failed to initialize
92 # the MEMBER or initialized the member to something invalid.
93 # By default, a check that the value is no longer equal to INIT
94 # is performed. The equation ``0'' disables the invalid_p check.
98 # printf style format string that can be used to print out the
99 # MEMBER. The default is to assume "%ld" is safe. Sometimes
100 # "%s" is useful. For functions, this is ignored and the
101 # function address is printed.
105 # An optional equation that converts the MEMBER into a value
106 # suitable for that FMT. By default it is assumed that the
107 # member's MACRO cast to long is safe.
111 # An optional indicator for any predicte to wrap around the
113 # # -> Wrap print up in ``#ifdef MACRO''
114 # exp -> Wrap print up in ``if (${print_p}) ...
128 # See below (DOCO) for description of each field
130 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct:::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
132 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
134 v:1:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address:0
135 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
136 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
137 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
138 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
139 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
140 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
141 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
142 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
143 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
145 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
146 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
147 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
148 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
149 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
150 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
152 v:2:NUM_REGS:int:num_regs::::0:-1
153 v:2:SP_REGNUM:int:sp_regnum::::0:-1
154 v:2:FP_REGNUM:int:fp_regnum::::0:-1
155 v:2:PC_REGNUM:int:pc_regnum::::0:-1
156 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr::0:0
157 v:2:REGISTER_SIZE:int:register_size::::0:-1
158 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
159 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
160 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
161 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
162 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
163 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
164 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
166 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
167 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
168 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:
169 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1::0x%08lx
170 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::0x%08lx
171 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
172 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
173 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
174 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
175 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:::0x%08lx
176 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:::0x%08lx
177 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1::0x%08lx
178 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
179 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
181 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::0:::::#
182 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::0:::::#
183 f:2:COERCE_FLOAT_TO_DOUBLE:int:coerce_float_to_double:struct type *formal, struct type *actual:formal, actual:::default_coerce_float_to_double
184 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
186 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr::0:0
187 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
188 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
190 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
191 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
192 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-::0:0
193 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp::0:0
194 f:2:POP_FRAME:void:pop_frame:void:-::0:0
196 # I wish that these would just go away....
197 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x::0:0
198 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x::0:0
199 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x::0:0
200 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x::0:0
201 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x::0:0
202 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x::0:0
204 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp::0:0
205 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf::0:0
206 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf::0:0
207 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type::0:0
209 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
210 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame::0:0
212 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
213 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
214 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:0
215 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint:0
216 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint:0
217 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
218 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
220 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
222 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
223 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi::0:0
224 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
225 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
226 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
227 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
228 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
229 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
230 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
241 function_list |
while eval read $read
244 ${class} ${macro}(${actual})
245 ${returntype} ${function} ($formal)${attrib}
249 invalid_p=${invalid_p}
253 description=${description}
262 /* Dynamic architecture support for GDB, the GNU debugger.
263 Copyright 1998-1999, Free Software Foundation, Inc.
265 This file is part of GDB.
267 This program is free software; you can redistribute it and/or modify
268 it under the terms of the GNU General Public License as published by
269 the Free Software Foundation; either version 2 of the License, or
270 (at your option) any later version.
272 This program is distributed in the hope that it will be useful,
273 but WITHOUT ANY WARRANTY; without even the implied warranty of
274 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
275 GNU General Public License for more details.
277 You should have received a copy of the GNU General Public License
278 along with this program; if not, write to the Free Software
279 Foundation, Inc., 59 Temple Place - Suite 330,
280 Boston, MA 02111-1307, USA. */
282 /* *INDENT-OFF* */ /* \`\`typedef (f)();'' confuses indent */
284 /* This file was created with the aid of \`\`gdbarch.sh''.
286 The bourn shell script \`\`gdbarch.sh'' creates the files
287 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
288 against the existing \`\`gdbarch.[hc]''. Any differences found
291 If editing this file, please also run gdbarch.sh and merge any
292 changes into that script. Conversely, when makeing sweeping changes
293 to this file, modifying gdbarch.sh and using its output may prove
313 #ifndef GDB_MULTI_ARCH
314 #define GDB_MULTI_ARCH 0
317 extern struct gdbarch *current_gdbarch;
320 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
324 /* If any of the following are defined, the target wasn't correctly
328 #if defined (CALL_DUMMY)
329 #error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
334 #if defined (REGISTER_NAMES)
335 #error "REGISTER_NAMES: replaced by REGISTER_NAME"
340 #if defined (EXTRA_FRAME_INFO)
341 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
346 #if defined (FRAME_FIND_SAVED_REGS)
347 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
355 echo "/* The following are pre-initialized by GDBARCH. */"
356 function_list |
while eval read $read
361 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
362 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
363 echo "#if GDB_MULTI_ARCH"
364 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
365 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
375 echo "/* The following are initialized by the target dependant code. */"
376 function_list |
while eval read $read
381 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
382 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
383 echo "#if GDB_MULTI_ARCH"
384 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
385 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
391 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
392 if [ "${formal}" = "void" ]
394 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
396 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
398 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
399 echo "#if GDB_MULTI_ARCH"
400 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
401 if [ "${actual}" = "" ]
403 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
404 elif [ "${actual}" = "-" ]
406 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
408 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
419 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
422 /* Mechanism for co-ordinating the selection of a specific
425 GDB targets (*-tdep.c) can register an interest in a specific
426 architecture. Other GDB components can register a need to maintain
427 per-architecture data.
429 The mechanisms below ensures that there is only a loose connection
430 between the set-architecture command and the various GDB
431 components. Each component can independantly register their need
432 to maintain architecture specific data with gdbarch.
436 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
439 The more traditional mega-struct containing architecture specific
440 data for all the various GDB components was also considered. Since
441 GDB is built from a variable number of (fairly independant)
442 components it was determined that the global aproach was not
446 /* Register a new architectural family with GDB.
448 Register support for the specified ARCHITECTURE with GDB. When
449 gdbarch determines that the specified architecture has been
450 selected, the corresponding INIT function is called.
454 The INIT function takes two parameters: INFO which contains the
455 information available to gdbarch about the (possibly new)
456 architecture; ARCHES which is a list of the previously created
457 \`\`struct gdbarch'' for this architecture.
459 The INIT function parameter INFO shall, as far as possible, be
460 pre-initialized with information obtained from INFO.ABFD or
461 previously selected architecture (if similar). INIT shall ensure
462 that the INFO.BYTE_ORDER is non-zero.
464 The INIT function shall return any of: NULL - indicating that it
465 doesn't reconize the selected architecture; an existing \`\`struct
466 gdbarch'' from the ARCHES list - indicating that the new
467 architecture is just a synonym for an earlier architecture (see
468 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
469 - that describes the selected architecture (see
474 struct gdbarch *gdbarch;
475 struct gdbarch_list *next;
480 /* Use default: bfd_arch_unknown (ZERO). */
481 enum bfd_architecture bfd_architecture;
483 /* Use default: NULL (ZERO). */
484 const struct bfd_arch_info *bfd_arch_info;
486 /* Use default: 0 (ZERO). */
489 /* Use default: NULL (ZERO). */
492 /* Use default: NULL (ZERO). */
493 struct gdbarch_tdep_info *tdep_info;
496 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
498 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
501 /* Helper function. Search the list of ARCHES for a GDBARCH that
502 matches the information provided by INFO. */
504 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
507 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
508 basic initialization using values obtained from the INFO andTDEP
509 parameters. set_gdbarch_*() functions are called to complete the
510 initialization of the object. */
512 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
515 /* Helper function. Free a partially-constructed \`\`struct gdbarch''. */
516 extern void gdbarch_free (struct gdbarch *);
519 /* Helper function. Force an update of the current architecture. Used
520 by legacy targets that have added their own target specific
521 architecture manipulation commands.
523 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
524 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
525 called. gdbarch_update() shall initialize any \`\`default'' fields
526 using information obtained from the previous architecture or
527 INFO.ABFD (if specified) before calling the corresponding
528 architectures INIT function. */
530 extern int gdbarch_update (struct gdbarch_info info);
534 /* Register per-architecture data-pointer.
536 Reserve space for a per-architecture data-pointer. An identifier
537 for the reserved data-pointer is returned. That identifer should
538 be saved in a local static.
540 When a new architecture is selected, INIT() is called. When a
541 previous architecture is re-selected, the per-architecture
542 data-pointer for that previous architecture is restored (INIT() is
545 INIT() shall return the initial value for the per-architecture
546 data-pointer for the current architecture.
548 Multiple registrarants for any architecture are allowed (and
549 strongly encouraged). */
551 typedef void *(gdbarch_data_ftype) (void);
552 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
554 /* Return the value of the per-architecture data-pointer for the
555 current architecture. */
557 extern void *gdbarch_data (struct gdbarch_data*);
561 /* Register per-architecture memory region.
563 Provide a memory-region swap mechanism. Per-architecture memory
564 region are created. These memory regions are swapped whenever the
565 architecture is changed. For a new architecture, the memory region
566 is initialized with zero (0) and the INIT function is called.
568 Memory regions are swapped / initialized in the order that they are
569 registered. NULL DATA and/or INIT values can be specified.
571 New code should use register_gdbarch_data(). */
573 typedef void (gdbarch_swap_ftype) (void);
574 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
575 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
579 /* The target-system-dependant byte order is dynamic */
581 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
582 is selectable at runtime. The user can use the \`\`set endian''
583 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
584 target_byte_order should be auto-detected (from the program image
588 /* Multi-arch GDB is always bi-endian. */
589 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
592 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
593 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
594 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
595 #ifdef TARGET_BYTE_ORDER_SELECTABLE
596 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
598 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
602 extern int target_byte_order;
603 #ifdef TARGET_BYTE_ORDER_SELECTABLE
604 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
605 and expect defs.h to re-define TARGET_BYTE_ORDER. */
606 #undef TARGET_BYTE_ORDER
608 #ifndef TARGET_BYTE_ORDER
609 #define TARGET_BYTE_ORDER (target_byte_order + 0)
612 extern int target_byte_order_auto;
613 #ifndef TARGET_BYTE_ORDER_AUTO
614 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
619 /* The target-system-dependant BFD architecture is dynamic */
621 extern int target_architecture_auto;
622 #ifndef TARGET_ARCHITECTURE_AUTO
623 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
626 extern const struct bfd_arch_info *target_architecture;
627 #ifndef TARGET_ARCHITECTURE
628 #define TARGET_ARCHITECTURE (target_architecture + 0)
631 /* Notify the target dependant backend of a change to the selected
632 architecture. A zero return status indicates that the target did
633 not like the change. */
635 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
639 /* The target-system-dependant disassembler is semi-dynamic */
641 #include "dis-asm.h" /* Get defs for disassemble_info */
643 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
644 unsigned int len, disassemble_info *info);
646 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
647 disassemble_info *info);
649 extern void dis_asm_print_address (bfd_vma addr,
650 disassemble_info *info);
652 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
653 extern disassemble_info tm_print_insn_info;
654 #ifndef TARGET_PRINT_INSN
655 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
657 #ifndef TARGET_PRINT_INSN_INFO
658 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
663 /* Explicit test for D10V architecture.
664 USE of these macro's is *STRONGLY* discouraged. */
666 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
667 #ifndef D10V_MAKE_DADDR
668 #define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
670 #ifndef D10V_MAKE_IADDR
671 #define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
675 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
676 #ifndef FRAMELESS_FUNCTION_INVOCATION
677 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
681 /* Fallback definition of REGISTER_CONVERTIBLE etc */
682 extern int generic_register_convertible_not (int reg_nr);
683 #ifndef REGISTER_CONVERTIBLE
684 #define REGISTER_CONVERTIBLE(x) (0)
686 #ifndef REGISTER_CONVERT_TO_VIRTUAL
687 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
689 #ifndef REGISTER_CONVERT_TO_RAW
690 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
694 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
695 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
696 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
697 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
699 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
700 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
705 /* Fallback definition for REGISTER_NAME for systems still defining
707 #ifndef REGISTER_NAME
708 extern char *gdb_register_names[];
709 #define REGISTER_NAME(i) gdb_register_names[i]
713 /* Set the dynamic target-system-dependant parameters (architecture,
714 byte-order, ...) using information found in the BFD */
716 extern void set_gdbarch_from_file (bfd *);
719 /* Explicitly set the dynamic target-system-dependant parameters based
720 on bfd_architecture and machine. */
722 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
725 /* Initialize the current architecture to the "first" one we find on
728 extern void initialize_current_architecture (void);
730 /* Helper function for targets that don't know how my arguments are
733 extern int frame_num_args_unknown (struct frame_info *fi);
736 /* gdbarch trace variable */
737 extern int gdbarch_debug;
739 extern void gdbarch_dump (void);
744 #../move-if-change new-gdbarch.h gdbarch.h
745 if ! test -r gdbarch.h
747 echo "gdbarch.h missing? cp new-gdbarch.h gdbarch.h" 1>&2
748 elif diff -c gdbarch.h new-gdbarch.h
750 echo "gdbarch.h unchanged" 1>&2
752 echo "gdbarch.h has changed? cp new-gdbarch.h gdbarch.h" 1>&2
768 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
770 /* Just include everything in sight so that the every old definition
771 of macro is visible. */
772 #include "gdb_string.h"
776 #include "inferior.h"
777 #include "breakpoint.h"
778 #include "gdb_wait.h"
782 #include "gdbthread.h"
783 #include "annotate.h"
784 #include "symfile.h" /* for overlay functions */
789 /* Static function declarations */
791 static void verify_gdbarch (struct gdbarch *gdbarch);
792 static void init_gdbarch_data (struct gdbarch *);
793 static void init_gdbarch_swap (struct gdbarch *);
794 static void swapout_gdbarch_swap (struct gdbarch *);
795 static void swapin_gdbarch_swap (struct gdbarch *);
797 /* Convenience macro for allocting typesafe memory. */
800 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
804 /* Non-zero if we want to trace architecture code. */
806 #ifndef GDBARCH_DEBUG
807 #define GDBARCH_DEBUG 0
809 int gdbarch_debug = GDBARCH_DEBUG;
813 # gdbarch open the gdbarch object
815 echo "/* Maintain the struct gdbarch object */"
817 echo "struct gdbarch"
819 echo " /* basic architectural information */"
820 function_list |
while eval read $read
823 "i" ) echo " ${returntype} ${function};" ;;
827 echo " /* target specific vector. */"
828 echo " struct gdbarch_tdep *tdep;"
830 echo " /* per-architecture data-pointers */"
834 echo " /* per-architecture swap-regions */"
835 echo " struct gdbarch_swap *swap;"
838 /* Multi-arch values.
840 When extending this structure you must:
844 Declare set/get functions and define the corresponding
847 gdbarch_alloc(): If zero/NULL is not a suitable default,
848 initialize the new field.
850 verify_gdbarch(): Confirm that the target updated the field
853 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
856 \`\`default_gdbarch()'': Append an initial value to the static
857 variable (base values on the host's c-type system).
859 get_gdbarch(): Implement the set/get functions (probably using
860 the macro's as shortcuts).
865 function_list |
while eval read $read
868 "v" ) echo " ${returntype} ${function};" ;;
869 "f" ) echo " gdbarch_${function}_ftype *${function}${attrib};" ;;
874 # A pre-initialized vector
878 /* The default architecture uses host values (for want of a better
882 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
884 echo "struct gdbarch default_gdbarch = {"
885 echo " /* basic architecture information */"
886 function_list |
while eval read $read
890 if [ "${default}" = "" ]; then
899 /* target specific vector */
901 /*per-architecture data-pointers and swap regions */
903 /* Multi-arch values */
905 function_list |
while eval read $read
909 if [ "${default}" = "" ]; then
918 /* default_gdbarch() */
920 struct gdbarch *current_gdbarch = &default_gdbarch;
923 # Create a new gdbarch struct
927 /* Create a new \`\`struct gdbarch'' based in information provided by
928 \`\`struct gdbarch_info''. */
933 gdbarch_alloc (const struct gdbarch_info *info,
934 struct gdbarch_tdep *tdep)
936 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
937 memset (gdbarch, 0, sizeof (*gdbarch));
939 gdbarch->tdep = tdep;
942 function_list |
while eval read $read
945 "i" ) echo " gdbarch->${function} = info->${function};"
949 echo " /* Force the explicit initialization of these. */"
950 function_list |
while eval read $read
954 if [ "${init}" != "" -a "${init}" != "0" ]
956 echo " gdbarch->${function} = ${init};"
962 /* gdbarch_alloc() */
968 # Free a gdbarch struct.
972 /* Free a gdbarch struct. This should never happen in normal
973 operation --- once you've created a gdbarch, you keep it around.
974 However, if an architecture's init function encounters an error
975 building the structure, it may need to clean up a partially
976 constructed gdbarch. */
978 gdbarch_free (struct gdbarch *arch)
980 /* At the moment, this is trivial. */
985 # verify a new architecture
988 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
992 verify_gdbarch (struct gdbarch *gdbarch)
994 /* Only perform sanity checks on a multi-arch target. */
995 if (GDB_MULTI_ARCH <= 0)
998 if (gdbarch->byte_order == 0)
999 internal_error ("verify_gdbarch: byte-order unset");
1000 if (gdbarch->bfd_arch_info == NULL)
1001 internal_error ("verify_gdbarch: bfd_arch_info unset");
1002 /* Check those that need to be defined for the given multi-arch level. */
1004 function_list |
while eval read $read
1008 if [ "${invalid_p}" ]
1010 echo " if ((GDB_MULTI_ARCH >= ${level})"
1011 echo " && (${invalid_p}))"
1012 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1015 echo " if ((GDB_MULTI_ARCH >= ${level})"
1016 echo " && (gdbarch->${function} == ${init}))"
1017 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1026 # dump the structure
1029 echo "/* Print out the details of the current architecture. */"
1036 function_list |
while eval read $read
1040 echo " fprintf_unfiltered (gdb_stdlog,"
1041 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1042 echo " (long) current_gdbarch->${function}"
1043 echo " /*${macro} ()*/);"
1046 test "${fmt}" ||
fmt="%ld"
1047 test "${print}" || print
="(long) ${macro}"
1048 if [ "${print_p}" = "#" ]
1050 echo "#ifdef ${macro}"
1051 echo " fprintf_unfiltered (gdb_stdlog,"
1052 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1055 elif [ "${print_p}" ]
1057 echo " if (${print_p})"
1058 echo " fprintf_unfiltered (gdb_stdlog,"
1059 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1062 echo " fprintf_unfiltered (gdb_stdlog,"
1063 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1075 struct gdbarch_tdep *
1076 gdbarch_tdep (struct gdbarch *gdbarch)
1078 if (gdbarch_debug >= 2)
1079 /* FIXME: gdb_std??? */
1080 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1081 return gdbarch->tdep;
1085 function_list |
while eval read $read
1090 echo "${returntype}"
1091 if [ "${formal}" = "void" ]
1093 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1095 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1098 echo " if (gdbarch->${function} == 0)"
1099 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1100 echo " if (gdbarch_debug >= 2)"
1101 echo " /* FIXME: gdb_std??? */"
1102 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1103 test "${actual}" = "-" && actual
=""
1104 if [ "${returntype}" = "void" ]
1106 echo " gdbarch->${function} (${actual});"
1108 echo " return gdbarch->${function} (${actual});"
1113 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1114 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1116 echo " gdbarch->${function} = ${function};"
1121 echo "${returntype}"
1122 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1124 if [ "${invalid_p}" ]
1126 echo " if (${invalid_p})"
1127 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1130 echo " if (gdbarch->${function} == ${init})"
1131 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1133 echo " if (gdbarch_debug >= 2)"
1134 echo " /* FIXME: gdb_std??? */"
1135 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1136 echo " return gdbarch->${function};"
1140 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1141 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1143 echo " gdbarch->${function} = ${function};"
1148 echo "${returntype}"
1149 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1151 echo " if (gdbarch_debug >= 2)"
1152 echo " /* FIXME: gdb_std??? */"
1153 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1154 echo " return gdbarch->${function};"
1160 # All the trailing guff
1164 /* Keep a registrary of per-architecture data-pointers required by GDB
1172 struct gdbarch_data_registration
1174 gdbarch_data_ftype *init;
1175 struct gdbarch_data *data;
1176 struct gdbarch_data_registration *next;
1179 struct gdbarch_data_registrary
1182 struct gdbarch_data_registration *registrations;
1185 struct gdbarch_data_registrary gdbarch_data_registrary =
1190 struct gdbarch_data *
1191 register_gdbarch_data (gdbarch_data_ftype *init)
1193 struct gdbarch_data_registration **curr;
1194 for (curr = &gdbarch_data_registrary.registrations;
1196 curr = &(*curr)->next);
1197 (*curr) = XMALLOC (struct gdbarch_data_registration);
1198 (*curr)->next = NULL;
1199 (*curr)->init = init;
1200 (*curr)->data = XMALLOC (struct gdbarch_data);
1201 (*curr)->data->index = gdbarch_data_registrary.nr++;
1202 return (*curr)->data;
1206 /* Walk through all the registered users initializing each in turn. */
1209 init_gdbarch_data (struct gdbarch *gdbarch)
1211 struct gdbarch_data_registration *rego;
1212 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1213 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1214 for (rego = gdbarch_data_registrary.registrations;
1218 if (rego->data->index < gdbarch->nr_data)
1219 gdbarch->data[rego->data->index] = rego->init ();
1224 /* Return the current value of the specified per-architecture
1229 struct gdbarch_data *data;
1231 if (data->index >= current_gdbarch->nr_data)
1232 internal_error ("gdbarch_data: request for non-existant data.");
1233 return current_gdbarch->data[data->index];
1238 /* Keep a registrary of swaped data required by GDB modules. */
1243 struct gdbarch_swap_registration *source;
1244 struct gdbarch_swap *next;
1247 struct gdbarch_swap_registration
1250 unsigned long sizeof_data;
1251 gdbarch_swap_ftype *init;
1252 struct gdbarch_swap_registration *next;
1255 struct gdbarch_swap_registrary
1258 struct gdbarch_swap_registration *registrations;
1261 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1267 register_gdbarch_swap (void *data,
1268 unsigned long sizeof_data,
1269 gdbarch_swap_ftype *init)
1271 struct gdbarch_swap_registration **rego;
1272 for (rego = &gdbarch_swap_registrary.registrations;
1274 rego = &(*rego)->next);
1275 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1276 (*rego)->next = NULL;
1277 (*rego)->init = init;
1278 (*rego)->data = data;
1279 (*rego)->sizeof_data = sizeof_data;
1284 init_gdbarch_swap (struct gdbarch *gdbarch)
1286 struct gdbarch_swap_registration *rego;
1287 struct gdbarch_swap **curr = &gdbarch->swap;
1288 for (rego = gdbarch_swap_registrary.registrations;
1292 if (rego->data != NULL)
1294 (*curr) = XMALLOC (struct gdbarch_swap);
1295 (*curr)->source = rego;
1296 (*curr)->swap = xmalloc (rego->sizeof_data);
1297 (*curr)->next = NULL;
1298 memset (rego->data, 0, rego->sizeof_data);
1299 curr = &(*curr)->next;
1301 if (rego->init != NULL)
1307 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1309 struct gdbarch_swap *curr;
1310 for (curr = gdbarch->swap;
1313 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1317 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1319 struct gdbarch_swap *curr;
1320 for (curr = gdbarch->swap;
1323 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1327 /* Keep a registrary of the architectures known by GDB. */
1329 struct gdbarch_init_registration
1331 enum bfd_architecture bfd_architecture;
1332 gdbarch_init_ftype *init;
1333 struct gdbarch_list *arches;
1334 struct gdbarch_init_registration *next;
1337 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1340 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1341 gdbarch_init_ftype *init)
1343 struct gdbarch_init_registration **curr;
1344 const struct bfd_arch_info *bfd_arch_info;
1345 /* Check that BFD reconizes this architecture */
1346 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1347 if (bfd_arch_info == NULL)
1349 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1351 /* Check that we haven't seen this architecture before */
1352 for (curr = &gdbarch_init_registrary;
1354 curr = &(*curr)->next)
1356 if (bfd_architecture == (*curr)->bfd_architecture)
1357 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1358 bfd_arch_info->printable_name);
1362 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1363 bfd_arch_info->printable_name,
1366 (*curr) = XMALLOC (struct gdbarch_init_registration);
1367 (*curr)->bfd_architecture = bfd_architecture;
1368 (*curr)->init = init;
1369 (*curr)->arches = NULL;
1370 (*curr)->next = NULL;
1375 /* Look for an architecture using gdbarch_info. Base search on only
1376 BFD_ARCH_INFO and BYTE_ORDER. */
1378 struct gdbarch_list *
1379 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1380 const struct gdbarch_info *info)
1382 for (; arches != NULL; arches = arches->next)
1384 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1386 if (info->byte_order != arches->gdbarch->byte_order)
1394 /* Update the current architecture. Return ZERO if the update request
1398 gdbarch_update (struct gdbarch_info info)
1400 struct gdbarch *new_gdbarch;
1401 struct gdbarch_list **list;
1402 struct gdbarch_init_registration *rego;
1404 /* Fill in any missing bits. Most important is the bfd_architecture
1405 which is used to select the target architecture. */
1406 if (info.bfd_architecture == bfd_arch_unknown)
1408 if (info.bfd_arch_info != NULL)
1409 info.bfd_architecture = info.bfd_arch_info->arch;
1410 else if (info.abfd != NULL)
1411 info.bfd_architecture = bfd_get_arch (info.abfd);
1412 /* FIXME - should query BFD for its default architecture. */
1414 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1416 if (info.bfd_arch_info == NULL)
1418 if (target_architecture_auto && info.abfd != NULL)
1419 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1421 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1423 if (info.byte_order == 0)
1425 if (target_byte_order_auto && info.abfd != NULL)
1426 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1427 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1430 info.byte_order = current_gdbarch->byte_order;
1431 /* FIXME - should query BFD for its default byte-order. */
1433 /* A default for abfd? */
1435 /* Find the target that knows about this architecture. */
1436 for (rego = gdbarch_init_registrary;
1437 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1442 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1448 fprintf_unfiltered (gdb_stdlog,
1449 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1450 info.bfd_architecture,
1451 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1452 fprintf_unfiltered (gdb_stdlog,
1453 "gdbarch_update: info.bfd_arch_info %s\n",
1454 (info.bfd_arch_info != NULL
1455 ? info.bfd_arch_info->printable_name
1457 fprintf_unfiltered (gdb_stdlog,
1458 "gdbarch_update: info.byte_order %d (%s)\n",
1460 (info.byte_order == BIG_ENDIAN ? "big"
1461 : info.byte_order == LITTLE_ENDIAN ? "little"
1463 fprintf_unfiltered (gdb_stdlog,
1464 "gdbarch_update: info.abfd 0x%lx\n",
1466 fprintf_unfiltered (gdb_stdlog,
1467 "gdbarch_update: info.tdep_info 0x%lx\n",
1468 (long) info.tdep_info);
1471 /* Ask the target for a replacement architecture. */
1472 new_gdbarch = rego->init (info, rego->arches);
1474 /* Did the target like it? No. Reject the change. */
1475 if (new_gdbarch == NULL)
1478 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1482 /* Did the architecture change? No. Do nothing. */
1483 if (current_gdbarch == new_gdbarch)
1486 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1488 new_gdbarch->bfd_arch_info->printable_name);
1492 /* Swap all data belonging to the old target out */
1493 swapout_gdbarch_swap (current_gdbarch);
1495 /* Is this a pre-existing architecture? Yes. Swap it in. */
1496 for (list = ®o->arches;
1498 list = &(*list)->next)
1500 if ((*list)->gdbarch == new_gdbarch)
1503 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1505 new_gdbarch->bfd_arch_info->printable_name);
1506 current_gdbarch = new_gdbarch;
1507 swapin_gdbarch_swap (new_gdbarch);
1512 /* Append this new architecture to this targets list. */
1513 (*list) = XMALLOC (struct gdbarch_list);
1514 (*list)->next = NULL;
1515 (*list)->gdbarch = new_gdbarch;
1517 /* Switch to this new architecture. Dump it out. */
1518 current_gdbarch = new_gdbarch;
1521 fprintf_unfiltered (gdb_stdlog,
1522 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1524 new_gdbarch->bfd_arch_info->printable_name);
1528 /* Check that the newly installed architecture is valid. */
1529 verify_gdbarch (new_gdbarch);
1531 /* Initialize the per-architecture memory (swap) areas.
1532 CURRENT_GDBARCH must be update before these modules are
1534 init_gdbarch_swap (new_gdbarch);
1536 /* Initialize the per-architecture data-pointer of all parties that
1537 registered an interest in this architecture. CURRENT_GDBARCH
1538 must be updated before these modules are called. */
1539 init_gdbarch_data (new_gdbarch);
1546 /* Functions to manipulate the endianness of the target. */
1548 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1549 /* compat - Catch old targets that expect a selectable byte-order to
1550 default to BIG_ENDIAN */
1551 #ifndef TARGET_BYTE_ORDER_DEFAULT
1552 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1555 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1556 #ifndef TARGET_BYTE_ORDER_DEFAULT
1557 /* compat - Catch old non byte-order selectable targets that do not
1558 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1559 TARGET_BYTE_ORDER to be used as the default. For targets that
1560 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1561 below will get a strange compiler warning. */
1562 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1565 #ifndef TARGET_BYTE_ORDER_DEFAULT
1566 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1568 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1569 int target_byte_order_auto = 1;
1571 /* Chain containing the \"set endian\" commands. */
1572 static struct cmd_list_element *endianlist = NULL;
1574 /* Called by \`\`show endian''. */
1576 show_endian (char *args, int from_tty)
1579 (TARGET_BYTE_ORDER_AUTO
1580 ? "The target endianness is set automatically (currently %s endian)\n"
1581 : "The target is assumed to be %s endian\n");
1582 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1585 /* Called if the user enters \`\`set endian'' without an argument. */
1587 set_endian (char *args, int from_tty)
1589 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1590 show_endian (args, from_tty);
1593 /* Called by \`\`set endian big''. */
1595 set_endian_big (char *args, int from_tty)
1597 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1599 target_byte_order = BIG_ENDIAN;
1600 target_byte_order_auto = 0;
1603 struct gdbarch_info info;
1604 memset (&info, 0, sizeof info);
1605 info.byte_order = BIG_ENDIAN;
1606 gdbarch_update (info);
1611 printf_unfiltered ("Byte order is not selectable.");
1612 show_endian (args, from_tty);
1616 /* Called by \`\`set endian little''. */
1618 set_endian_little (char *args, int from_tty)
1620 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1622 target_byte_order = LITTLE_ENDIAN;
1623 target_byte_order_auto = 0;
1626 struct gdbarch_info info;
1627 memset (&info, 0, sizeof info);
1628 info.byte_order = LITTLE_ENDIAN;
1629 gdbarch_update (info);
1634 printf_unfiltered ("Byte order is not selectable.");
1635 show_endian (args, from_tty);
1639 /* Called by \`\`set endian auto''. */
1641 set_endian_auto (char *args, int from_tty)
1643 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1645 target_byte_order_auto = 1;
1649 printf_unfiltered ("Byte order is not selectable.");
1650 show_endian (args, from_tty);
1654 /* Set the endianness from a BFD. */
1656 set_endian_from_file (bfd *abfd)
1658 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1662 if (bfd_big_endian (abfd))
1665 want = LITTLE_ENDIAN;
1666 if (TARGET_BYTE_ORDER_AUTO)
1667 target_byte_order = want;
1668 else if (TARGET_BYTE_ORDER != want)
1669 warning ("%s endian file does not match %s endian target.",
1670 want == BIG_ENDIAN ? "big" : "little",
1671 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1675 if (bfd_big_endian (abfd)
1676 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1677 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1678 warning ("%s endian file does not match %s endian target.",
1679 bfd_big_endian (abfd) ? "big" : "little",
1680 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1686 /* Functions to manipulate the architecture of the target */
1688 enum set_arch { set_arch_auto, set_arch_manual };
1690 int target_architecture_auto = 1;
1691 extern const struct bfd_arch_info bfd_default_arch_struct;
1692 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1693 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1695 static void show_endian (char *, int);
1696 static void set_endian (char *, int);
1697 static void set_endian_big (char *, int);
1698 static void set_endian_little (char *, int);
1699 static void set_endian_auto (char *, int);
1700 static void set_endian_from_file (bfd *);
1701 static int arch_ok (const struct bfd_arch_info *arch);
1702 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1703 static void show_architecture (char *, int);
1704 static void set_architecture (char *, int);
1705 static void info_architecture (char *, int);
1706 static void set_architecture_from_file (bfd *);
1708 /* Do the real work of changing the current architecture */
1711 arch_ok (const struct bfd_arch_info *arch)
1713 /* Should be performing the more basic check that the binary is
1714 compatible with GDB. */
1715 /* Check with the target that the architecture is valid. */
1716 return (target_architecture_hook == NULL
1717 || target_architecture_hook (arch));
1721 set_arch (const struct bfd_arch_info *arch,
1727 if (!arch_ok (arch))
1728 warning ("Target may not support %s architecture",
1729 arch->printable_name);
1730 target_architecture = arch;
1732 case set_arch_manual:
1733 if (!arch_ok (arch))
1735 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1736 arch->printable_name);
1740 target_architecture_auto = 0;
1741 target_architecture = arch;
1749 /* Called if the user enters \`\`show architecture'' without an argument. */
1751 show_architecture (char *args, int from_tty)
1754 arch = TARGET_ARCHITECTURE->printable_name;
1755 if (target_architecture_auto)
1756 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1758 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1761 /* Called if the user enters \`\`set architecture'' with or without an
1764 set_architecture (char *args, int from_tty)
1768 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1770 else if (strcmp (args, "auto") == 0)
1772 target_architecture_auto = 1;
1774 else if (GDB_MULTI_ARCH)
1776 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1778 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1781 struct gdbarch_info info;
1782 memset (&info, 0, sizeof info);
1783 info.bfd_arch_info = arch;
1784 if (gdbarch_update (info))
1785 target_architecture_auto = 0;
1787 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1792 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1794 set_arch (arch, set_arch_manual);
1796 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1800 /* Called if the user enters \`\`info architecture'' without an argument. */
1802 info_architecture (char *args, int from_tty)
1804 enum bfd_architecture a;
1807 if (gdbarch_init_registrary != NULL)
1809 struct gdbarch_init_registration *rego;
1810 printf_filtered ("Available architectures are:\n");
1811 for (rego = gdbarch_init_registrary;
1815 const struct bfd_arch_info *ap;
1816 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1821 printf_filtered (" %s", ap->printable_name);
1825 printf_filtered ("\n");
1831 printf_filtered ("There are no available architectures.\n");
1835 printf_filtered ("Available architectures are:\n");
1836 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1838 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1843 printf_filtered (" %s", ap->printable_name);
1847 printf_filtered ("\n");
1852 /* Set the architecture from arch/machine */
1854 set_architecture_from_arch_mach (arch, mach)
1855 enum bfd_architecture arch;
1858 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1860 set_arch (wanted, set_arch_manual);
1862 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1865 /* Set the architecture from a BFD */
1867 set_architecture_from_file (bfd *abfd)
1869 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1870 if (target_architecture_auto)
1872 set_arch (wanted, set_arch_auto);
1874 else if (wanted != target_architecture)
1876 warning ("%s architecture file may be incompatible with %s target.",
1877 wanted->printable_name,
1878 target_architecture->printable_name);
1883 /* Misc helper functions for targets. */
1886 frame_num_args_unknown (fi)
1887 struct frame_info *fi;
1894 generic_register_convertible_not (num)
1902 /* Pointer to the target-dependent disassembly function. */
1903 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1904 disassemble_info tm_print_insn_info;
1908 /* Set the dynamic target-system-dependant parameters (architecture,
1909 byte-order) using information found in the BFD */
1912 set_gdbarch_from_file (abfd)
1917 struct gdbarch_info info;
1918 memset (&info, 0, sizeof info);
1920 gdbarch_update (info);
1923 set_architecture_from_file (abfd);
1924 set_endian_from_file (abfd);
1928 #if defined (CALL_DUMMY)
1929 /* FIXME - this should go away */
1930 LONGEST call_dummy_words[] = CALL_DUMMY;
1931 int sizeof_call_dummy_words = sizeof (call_dummy_words);
1935 /* Initialize the current architecture. */
1937 initialize_current_architecture ()
1941 struct gdbarch_init_registration *rego;
1942 const struct bfd_arch_info *chosen = NULL;
1943 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
1945 const struct bfd_arch_info *ap
1946 = bfd_lookup_arch (rego->bfd_architecture, 0);
1948 /* Choose the first architecture alphabetically. */
1950 || strcmp (ap->printable_name, chosen->printable_name) < 0)
1956 struct gdbarch_info info;
1957 memset (&info, 0, sizeof info);
1958 info.bfd_arch_info = chosen;
1959 gdbarch_update (info);
1964 extern void _initialize_gdbarch (void);
1966 _initialize_gdbarch ()
1968 add_prefix_cmd ("endian", class_support, set_endian,
1969 "Set endianness of target.",
1970 &endianlist, "set endian ", 0, &setlist);
1971 add_cmd ("big", class_support, set_endian_big,
1972 "Set target as being big endian.", &endianlist);
1973 add_cmd ("little", class_support, set_endian_little,
1974 "Set target as being little endian.", &endianlist);
1975 add_cmd ("auto", class_support, set_endian_auto,
1976 "Select target endianness automatically.", &endianlist);
1977 add_cmd ("endian", class_support, show_endian,
1978 "Show endianness of target.", &showlist);
1980 add_cmd ("architecture", class_support, set_architecture,
1981 "Set architecture of target.", &setlist);
1982 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
1983 add_cmd ("architecture", class_support, show_architecture,
1984 "Show architecture of target.", &showlist);
1985 add_cmd ("architecture", class_support, info_architecture,
1986 "List supported target architectures", &infolist);
1988 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1989 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1990 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1991 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1992 tm_print_insn_info.print_address_func = dis_asm_print_address;
1994 add_show_from_set (add_set_cmd ("archdebug",
1997 (char *)&gdbarch_debug,
1998 "Set architecture debugging.\n\\
1999 When non-zero, architecture debugging is enabled.", &setlist),
2006 #../move-if-change new-gdbarch.c gdbarch.c
2007 if ! test -r gdbarch.c
2009 echo "gdbarch.c missing? cp new-gdbarch.c gdbarch.c" 1>&2
2010 elif diff -c gdbarch.c new-gdbarch.c
2012 echo "gdbarch.c unchanged" 1>&2
2014 echo "gdbarch.c has changed? cp new-gdbarch.c gdbarch.c" 1>&2