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: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
185 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr::0:0
186 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
187 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
189 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
190 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
191 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-::0:0
192 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp::0:0
193 f:2:POP_FRAME:void:pop_frame:void:-::0:0
195 # I wish that these would just go away....
196 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x::0:0
197 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x::0:0
198 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x::0:0
199 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x::0:0
200 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x::0:0
201 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x::0:0
203 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp::0:0
204 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf::0:0
205 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf::0:0
206 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type::0:0
208 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
209 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame::0:0
211 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
212 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
213 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:0
214 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint:0
215 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint:0
216 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
217 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
219 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
221 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
222 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi::0:0
223 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
224 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
225 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
226 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
227 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
228 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
229 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
240 function_list | while eval read $read
243 ${class} ${macro}(${actual})
244 ${returntype} ${function} ($formal)${attrib}
248 invalid_p=${invalid_p}
252 description=${description}
261 /* Dynamic architecture support for GDB, the GNU debugger.
262 Copyright 1998-1999, Free Software Foundation, Inc.
264 This file is part of GDB.
266 This program is free software; you can redistribute it and/or modify
267 it under the terms of the GNU General Public License as published by
268 the Free Software Foundation; either version 2 of the License, or
269 (at your option) any later version.
271 This program is distributed in the hope that it will be useful,
272 but WITHOUT ANY WARRANTY; without even the implied warranty of
273 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
274 GNU General Public License for more details.
276 You should have received a copy of the GNU General Public License
277 along with this program; if not, write to the Free Software
278 Foundation, Inc., 59 Temple Place - Suite 330,
279 Boston, MA 02111-1307, USA. */
281 /* *INDENT-OFF* */ /* \`\`typedef (f)();'' confuses indent */
283 /* This file was created with the aid of \`\`gdbarch.sh''.
285 The bourn shell script \`\`gdbarch.sh'' creates the files
286 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
287 against the existing \`\`gdbarch.[hc]''. Any differences found
290 If editing this file, please also run gdbarch.sh and merge any
291 changes into that script. Conversely, when makeing sweeping changes
292 to this file, modifying gdbarch.sh and using its output may prove
312 #ifndef GDB_MULTI_ARCH
313 #define GDB_MULTI_ARCH 0
316 extern struct gdbarch *current_gdbarch;
319 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
323 /* If any of the following are defined, the target wasn't correctly
327 #if defined (CALL_DUMMY)
328 #error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
333 #if defined (REGISTER_NAMES)
334 #error "REGISTER_NAMES: replaced by REGISTER_NAME"
339 #if defined (EXTRA_FRAME_INFO)
340 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
345 #if defined (FRAME_FIND_SAVED_REGS)
346 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
354 echo "/* The following are pre-initialized by GDBARCH. */"
355 function_list | while eval read $read
360 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
361 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
362 echo "#if GDB_MULTI_ARCH"
363 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
364 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
374 echo "/* The following are initialized by the target dependant code. */"
375 function_list | while eval read $read
380 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
381 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
382 echo "#if GDB_MULTI_ARCH"
383 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
384 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
390 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
391 if [ "${formal}" = "void" ]
393 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
395 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
397 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
398 echo "#if GDB_MULTI_ARCH"
399 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
400 if [ "${actual}" = "" ]
402 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
403 elif [ "${actual}" = "-" ]
405 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
407 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
418 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
421 /* Mechanism for co-ordinating the selection of a specific
424 GDB targets (*-tdep.c) can register an interest in a specific
425 architecture. Other GDB components can register a need to maintain
426 per-architecture data.
428 The mechanisms below ensures that there is only a loose connection
429 between the set-architecture command and the various GDB
430 components. Each component can independantly register their need
431 to maintain architecture specific data with gdbarch.
435 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
438 The more traditional mega-struct containing architecture specific
439 data for all the various GDB components was also considered. Since
440 GDB is built from a variable number of (fairly independant)
441 components it was determined that the global aproach was not
445 /* Register a new architectural family with GDB.
447 Register support for the specified ARCHITECTURE with GDB. When
448 gdbarch determines that the specified architecture has been
449 selected, the corresponding INIT function is called.
453 The INIT function takes two parameters: INFO which contains the
454 information available to gdbarch about the (possibly new)
455 architecture; ARCHES which is a list of the previously created
456 \`\`struct gdbarch'' for this architecture.
458 The INIT function parameter INFO shall, as far as possible, be
459 pre-initialized with information obtained from INFO.ABFD or
460 previously selected architecture (if similar). INIT shall ensure
461 that the INFO.BYTE_ORDER is non-zero.
463 The INIT function shall return any of: NULL - indicating that it
464 doesn't reconize the selected architecture; an existing \`\`struct
465 gdbarch'' from the ARCHES list - indicating that the new
466 architecture is just a synonym for an earlier architecture (see
467 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
468 - that describes the selected architecture (see
473 struct gdbarch *gdbarch;
474 struct gdbarch_list *next;
479 /* Use default: bfd_arch_unknown (ZERO). */
480 enum bfd_architecture bfd_architecture;
482 /* Use default: NULL (ZERO). */
483 const struct bfd_arch_info *bfd_arch_info;
485 /* Use default: 0 (ZERO). */
488 /* Use default: NULL (ZERO). */
491 /* Use default: NULL (ZERO). */
492 struct gdbarch_tdep_info *tdep_info;
495 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
497 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
500 /* Helper function. Search the list of ARCHES for a GDBARCH that
501 matches the information provided by INFO. */
503 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
506 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
507 basic initialization using values obtained from the INFO andTDEP
508 parameters. set_gdbarch_*() functions are called to complete the
509 initialization of the object. */
511 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
514 /* Helper function. Force an update of the current architecture. Used
515 by legacy targets that have added their own target specific
516 architecture manipulation commands.
518 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
519 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
520 called. gdbarch_update() shall initialize any \`\`default'' fields
521 using information obtained from the previous architecture or
522 INFO.ABFD (if specified) before calling the corresponding
523 architectures INIT function. */
525 extern int gdbarch_update (struct gdbarch_info info);
529 /* Register per-architecture data-pointer.
531 Reserve space for a per-architecture data-pointer. An identifier
532 for the reserved data-pointer is returned. That identifer should
533 be saved in a local static.
535 When a new architecture is selected, INIT() is called. When a
536 previous architecture is re-selected, the per-architecture
537 data-pointer for that previous architecture is restored (INIT() is
540 INIT() shall return the initial value for the per-architecture
541 data-pointer for the current architecture.
543 Multiple registrarants for any architecture are allowed (and
544 strongly encouraged). */
546 typedef void *(gdbarch_data_ftype) (void);
547 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
549 /* Return the value of the per-architecture data-pointer for the
550 current architecture. */
552 extern void *gdbarch_data (struct gdbarch_data*);
556 /* Register per-architecture memory region.
558 Provide a memory-region swap mechanism. Per-architecture memory
559 region are created. These memory regions are swapped whenever the
560 architecture is changed. For a new architecture, the memory region
561 is initialized with zero (0) and the INIT function is called.
563 Memory regions are swapped / initialized in the order that they are
564 registered. NULL DATA and/or INIT values can be specified.
566 New code should use register_gdbarch_data(). */
568 typedef void (gdbarch_swap_ftype) (void);
569 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
570 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
574 /* The target-system-dependant byte order is dynamic */
576 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
577 is selectable at runtime. The user can use the \`\`set endian''
578 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
579 target_byte_order should be auto-detected (from the program image
583 /* Multi-arch GDB is always bi-endian. */
584 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
587 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
588 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
589 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
590 #ifdef TARGET_BYTE_ORDER_SELECTABLE
591 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
593 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
597 extern int target_byte_order;
598 #ifdef TARGET_BYTE_ORDER_SELECTABLE
599 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
600 and expect defs.h to re-define TARGET_BYTE_ORDER. */
601 #undef TARGET_BYTE_ORDER
603 #ifndef TARGET_BYTE_ORDER
604 #define TARGET_BYTE_ORDER (target_byte_order + 0)
607 extern int target_byte_order_auto;
608 #ifndef TARGET_BYTE_ORDER_AUTO
609 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
614 /* The target-system-dependant BFD architecture is dynamic */
616 extern int target_architecture_auto;
617 #ifndef TARGET_ARCHITECTURE_AUTO
618 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
621 extern const struct bfd_arch_info *target_architecture;
622 #ifndef TARGET_ARCHITECTURE
623 #define TARGET_ARCHITECTURE (target_architecture + 0)
626 /* Notify the target dependant backend of a change to the selected
627 architecture. A zero return status indicates that the target did
628 not like the change. */
630 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
634 /* The target-system-dependant disassembler is semi-dynamic */
636 #include "dis-asm.h" /* Get defs for disassemble_info */
638 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
639 int len, disassemble_info *info);
641 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
642 disassemble_info *info);
644 extern void dis_asm_print_address (bfd_vma addr,
645 disassemble_info *info);
647 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
648 extern disassemble_info tm_print_insn_info;
649 #ifndef TARGET_PRINT_INSN
650 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
652 #ifndef TARGET_PRINT_INSN_INFO
653 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
658 /* Explicit test for D10V architecture.
659 USE of these macro's is *STRONGLY* discouraged. */
661 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
662 #ifndef D10V_MAKE_DADDR
663 #define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
665 #ifndef D10V_MAKE_IADDR
666 #define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
670 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
671 #ifndef FRAMELESS_FUNCTION_INVOCATION
672 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
676 /* Fallback definition of REGISTER_CONVERTIBLE etc */
677 extern int generic_register_convertible_not (int reg_nr);
678 #ifndef REGISTER_CONVERTIBLE
679 #define REGISTER_CONVERTIBLE(x) (0)
681 #ifndef REGISTER_CONVERT_TO_VIRTUAL
682 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
684 #ifndef REGISTER_CONVERT_TO_RAW
685 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
689 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
690 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
691 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
692 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
694 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
695 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
700 /* Fallback definition for REGISTER_NAME for systems still defining
702 #ifndef REGISTER_NAME
703 extern char *gdb_register_names[];
704 #define REGISTER_NAME(i) gdb_register_names[i]
708 /* Set the dynamic target-system-dependant parameters (architecture,
709 byte-order, ...) using information found in the BFD */
711 extern void set_gdbarch_from_file (bfd *);
714 /* Explicitly set the dynamic target-system-dependant parameters based
715 on bfd_architecture and machine. */
717 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
720 /* Initialize the current architecture to the "first" one we find on
723 extern void initialize_current_architecture (void);
725 /* Helper function for targets that don't know how my arguments are
728 extern int frame_num_args_unknown (struct frame_info *fi);
731 /* gdbarch trace variable */
732 extern int gdbarch_debug;
734 extern void gdbarch_dump (void);
739 #../move-if-change new-gdbarch.h gdbarch.h
740 if ! test -r gdbarch.h
742 echo "gdbarch.h missing? cp new-gdbarch.h gdbarch.h" 1>&2
743 elif diff -c gdbarch.h new-gdbarch.h
745 echo "gdbarch.h unchanged" 1>&2
747 echo "gdbarch.h has changed? cp new-gdbarch.h gdbarch.h" 1>&2
763 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
765 /* Just include everything in sight so that the every old definition
766 of macro is visible. */
767 #include "gdb_string.h"
771 #include "inferior.h"
772 #include "breakpoint.h"
773 #include "gdb_wait.h"
777 #include "gdbthread.h"
778 #include "annotate.h"
779 #include "symfile.h" /* for overlay functions */
784 /* Static function declarations */
786 static void verify_gdbarch (struct gdbarch *gdbarch);
787 static void init_gdbarch_data (struct gdbarch *);
788 static void init_gdbarch_swap (struct gdbarch *);
789 static void swapout_gdbarch_swap (struct gdbarch *);
790 static void swapin_gdbarch_swap (struct gdbarch *);
792 /* Convenience macro for allocting typesafe memory. */
795 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
799 /* Non-zero if we want to trace architecture code. */
801 #ifndef GDBARCH_DEBUG
802 #define GDBARCH_DEBUG 0
804 int gdbarch_debug = GDBARCH_DEBUG;
808 # gdbarch open the gdbarch object
810 echo "/* Maintain the struct gdbarch object */"
812 echo "struct gdbarch"
814 echo " /* basic architectural information */"
815 function_list | while eval read $read
818 "i" ) echo " ${returntype} ${function};" ;;
822 echo " /* target specific vector. */"
823 echo " struct gdbarch_tdep *tdep;"
825 echo " /* per-architecture data-pointers */"
829 echo " /* per-architecture swap-regions */"
830 echo " struct gdbarch_swap *swap;"
833 /* Multi-arch values.
835 When extending this structure you must:
839 Declare set/get functions and define the corresponding
842 gdbarch_alloc(): If zero/NULL is not a suitable default,
843 initialize the new field.
845 verify_gdbarch(): Confirm that the target updated the field
848 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
851 \`\`default_gdbarch()'': Append an initial value to the static
852 variable (base values on the host's c-type system).
854 get_gdbarch(): Implement the set/get functions (probably using
855 the macro's as shortcuts).
860 function_list | while eval read $read
863 "v" ) echo " ${returntype} ${function};" ;;
864 "f" ) echo " gdbarch_${function}_ftype *${function}${attrib};" ;;
869 # A pre-initialized vector
873 /* The default architecture uses host values (for want of a better
877 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
879 echo "struct gdbarch default_gdbarch = {"
880 echo " /* basic architecture information */"
881 function_list | while eval read $read
884 "i" ) echo " ${default}," ;;
888 /* target specific vector */
890 /*per-architecture data-pointers and swap regions */
892 /* Multi-arch values */
894 function_list | while eval read $read
897 "f" | "v" ) echo " ${default}," ;;
901 /* default_gdbarch() */
903 struct gdbarch *current_gdbarch = &default_gdbarch;
906 # Create a new gdbarch struct
910 /* Create a new \`\`struct gdbarch'' based in information provided by
911 \`\`struct gdbarch_info''. */
916 gdbarch_alloc (const struct gdbarch_info *info,
917 struct gdbarch_tdep *tdep)
919 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
920 memset (gdbarch, 0, sizeof (*gdbarch));
922 gdbarch->tdep = tdep;
925 function_list | while eval read $read
928 "i" ) echo " gdbarch->${function} = info->${function};"
932 echo " /* Force the explicit initialization of these. */"
933 function_list | while eval read $read
937 if [ "${init}" != "" -a "${init}" != "0" ]
939 echo " gdbarch->${function} = ${init};"
945 /* gdbarch_alloc() */
951 # verify a new architecture
954 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
958 verify_gdbarch (struct gdbarch *gdbarch)
960 /* Only perform sanity checks on a multi-arch target. */
961 if (GDB_MULTI_ARCH <= 0)
964 if (gdbarch->byte_order == 0)
965 internal_error ("verify_gdbarch: byte-order unset");
966 if (gdbarch->bfd_arch_info == NULL)
967 internal_error ("verify_gdbarch: bfd_arch_info unset");
968 /* Check those that need to be defined for the given multi-arch level. */
970 function_list | while eval read $read
974 if [ "${invalid_p}" ]
976 echo " if ((GDB_MULTI_ARCH >= ${level})"
977 echo " && (${invalid_p}))"
978 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
981 echo " if ((GDB_MULTI_ARCH >= ${level})"
982 echo " && (gdbarch->${function} == ${init}))"
983 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
995 echo "/* Print out the details of the current architecture. */"
1002 function_list | while eval read $read
1006 echo " fprintf_unfiltered (gdb_stdlog,"
1007 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1008 echo " (long) current_gdbarch->${function}"
1009 echo " /*${macro} ()*/);"
1012 test "${fmt}" || fmt="%ld"
1013 test "${print}" || print="(long) ${macro}"
1014 if [ "${print_p}" = "#" ]
1016 echo "#ifdef ${macro}"
1017 echo " fprintf_unfiltered (gdb_stdlog,"
1018 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1021 elif [ "${print_p}" ]
1023 echo " if (${print_p})"
1024 echo " fprintf_unfiltered (gdb_stdlog,"
1025 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1028 echo " fprintf_unfiltered (gdb_stdlog,"
1029 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1041 struct gdbarch_tdep *
1042 gdbarch_tdep (struct gdbarch *gdbarch)
1044 if (gdbarch_debug >= 2)
1045 /* FIXME: gdb_std??? */
1046 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1047 return gdbarch->tdep;
1051 function_list | while eval read $read
1056 echo "${returntype}"
1057 if [ "${formal}" = "void" ]
1059 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1061 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1064 echo " if (gdbarch->${function} == 0)"
1065 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1066 echo " if (gdbarch_debug >= 2)"
1067 echo " /* FIXME: gdb_std??? */"
1068 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1069 test "${actual}" = "-" && actual=""
1070 if [ "${returntype}" = "void" ]
1072 echo " gdbarch->${function} (${actual});"
1074 echo " return gdbarch->${function} (${actual});"
1079 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1080 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1082 echo " gdbarch->${function} = ${function};"
1087 echo "${returntype}"
1088 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1090 if [ "${invalid_p}" ]
1092 echo " if (${invalid_p})"
1093 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1096 echo " if (gdbarch->${function} == ${init})"
1097 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1099 echo " if (gdbarch_debug >= 2)"
1100 echo " /* FIXME: gdb_std??? */"
1101 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1102 echo " return gdbarch->${function};"
1106 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1107 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1109 echo " gdbarch->${function} = ${function};"
1114 echo "${returntype}"
1115 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1117 echo " if (gdbarch_debug >= 2)"
1118 echo " /* FIXME: gdb_std??? */"
1119 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1120 echo " return gdbarch->${function};"
1126 # All the trailing guff
1130 /* Keep a registrary of per-architecture data-pointers required by GDB
1138 struct gdbarch_data_registration
1140 gdbarch_data_ftype *init;
1141 struct gdbarch_data *data;
1142 struct gdbarch_data_registration *next;
1145 struct gdbarch_data_registrary
1148 struct gdbarch_data_registration *registrations;
1151 struct gdbarch_data_registrary gdbarch_data_registrary =
1156 struct gdbarch_data *
1157 register_gdbarch_data (gdbarch_data_ftype *init)
1159 struct gdbarch_data_registration **curr;
1160 for (curr = &gdbarch_data_registrary.registrations;
1162 curr = &(*curr)->next);
1163 (*curr) = XMALLOC (struct gdbarch_data_registration);
1164 (*curr)->next = NULL;
1165 (*curr)->init = init;
1166 (*curr)->data = XMALLOC (struct gdbarch_data);
1167 (*curr)->data->index = gdbarch_data_registrary.nr++;
1168 return (*curr)->data;
1172 /* Walk through all the registered users initializing each in turn. */
1175 init_gdbarch_data (struct gdbarch *gdbarch)
1177 struct gdbarch_data_registration *rego;
1178 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1179 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1180 for (rego = gdbarch_data_registrary.registrations;
1184 if (rego->data->index < gdbarch->nr_data)
1185 gdbarch->data[rego->data->index] = rego->init ();
1190 /* Return the current value of the specified per-architecture
1195 struct gdbarch_data *data;
1197 if (data->index >= current_gdbarch->nr_data)
1198 internal_error ("gdbarch_data: request for non-existant data.");
1199 return current_gdbarch->data[data->index];
1204 /* Keep a registrary of swaped data required by GDB modules. */
1209 struct gdbarch_swap_registration *source;
1210 struct gdbarch_swap *next;
1213 struct gdbarch_swap_registration
1216 unsigned long sizeof_data;
1217 gdbarch_swap_ftype *init;
1218 struct gdbarch_swap_registration *next;
1221 struct gdbarch_swap_registrary
1224 struct gdbarch_swap_registration *registrations;
1227 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1233 register_gdbarch_swap (void *data,
1234 unsigned long sizeof_data,
1235 gdbarch_swap_ftype *init)
1237 struct gdbarch_swap_registration **rego;
1238 for (rego = &gdbarch_swap_registrary.registrations;
1240 rego = &(*rego)->next);
1241 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1242 (*rego)->next = NULL;
1243 (*rego)->init = init;
1244 (*rego)->data = data;
1245 (*rego)->sizeof_data = sizeof_data;
1250 init_gdbarch_swap (struct gdbarch *gdbarch)
1252 struct gdbarch_swap_registration *rego;
1253 struct gdbarch_swap **curr = &gdbarch->swap;
1254 for (rego = gdbarch_swap_registrary.registrations;
1258 if (rego->data != NULL)
1260 (*curr) = XMALLOC (struct gdbarch_swap);
1261 (*curr)->source = rego;
1262 (*curr)->swap = xmalloc (rego->sizeof_data);
1263 (*curr)->next = NULL;
1264 memset (rego->data, 0, rego->sizeof_data);
1265 curr = &(*curr)->next;
1267 if (rego->init != NULL)
1273 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1275 struct gdbarch_swap *curr;
1276 for (curr = gdbarch->swap;
1279 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1283 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1285 struct gdbarch_swap *curr;
1286 for (curr = gdbarch->swap;
1289 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1293 /* Keep a registrary of the architectures known by GDB. */
1295 struct gdbarch_init_registration
1297 enum bfd_architecture bfd_architecture;
1298 gdbarch_init_ftype *init;
1299 struct gdbarch_list *arches;
1300 struct gdbarch_init_registration *next;
1303 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1306 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1307 gdbarch_init_ftype *init)
1309 struct gdbarch_init_registration **curr;
1310 const struct bfd_arch_info *bfd_arch_info;
1311 /* Check that BFD reconizes this architecture */
1312 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1313 if (bfd_arch_info == NULL)
1315 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1317 /* Check that we haven't seen this architecture before */
1318 for (curr = &gdbarch_init_registrary;
1320 curr = &(*curr)->next)
1322 if (bfd_architecture == (*curr)->bfd_architecture)
1323 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1324 bfd_arch_info->printable_name);
1328 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1329 bfd_arch_info->printable_name,
1332 (*curr) = XMALLOC (struct gdbarch_init_registration);
1333 (*curr)->bfd_architecture = bfd_architecture;
1334 (*curr)->init = init;
1335 (*curr)->arches = NULL;
1336 (*curr)->next = NULL;
1341 /* Look for an architecture using gdbarch_info. Base search on only
1342 BFD_ARCH_INFO and BYTE_ORDER. */
1344 struct gdbarch_list *
1345 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1346 const struct gdbarch_info *info)
1348 for (; arches != NULL; arches = arches->next)
1350 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1352 if (info->byte_order != arches->gdbarch->byte_order)
1360 /* Update the current architecture. Return ZERO if the update request
1364 gdbarch_update (struct gdbarch_info info)
1366 struct gdbarch *new_gdbarch;
1367 struct gdbarch_list **list;
1368 struct gdbarch_init_registration *rego;
1370 /* Fill in any missing bits. Most important is the bfd_architecture
1371 which is used to select the target architecture. */
1372 if (info.bfd_architecture == bfd_arch_unknown)
1374 if (info.bfd_arch_info != NULL)
1375 info.bfd_architecture = info.bfd_arch_info->arch;
1376 else if (info.abfd != NULL)
1377 info.bfd_architecture = bfd_get_arch (info.abfd);
1378 /* FIXME - should query BFD for its default architecture. */
1380 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1382 if (info.bfd_arch_info == NULL)
1384 if (target_architecture_auto && info.abfd != NULL)
1385 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1387 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1389 if (info.byte_order == 0)
1391 if (target_byte_order_auto && info.abfd != NULL)
1392 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1393 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1396 info.byte_order = current_gdbarch->byte_order;
1397 /* FIXME - should query BFD for its default byte-order. */
1399 /* A default for abfd? */
1401 /* Find the target that knows about this architecture. */
1402 for (rego = gdbarch_init_registrary;
1403 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1408 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1414 fprintf_unfiltered (gdb_stdlog,
1415 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1416 info.bfd_architecture,
1417 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1418 fprintf_unfiltered (gdb_stdlog,
1419 "gdbarch_update: info.bfd_arch_info %s\n",
1420 (info.bfd_arch_info != NULL
1421 ? info.bfd_arch_info->printable_name
1423 fprintf_unfiltered (gdb_stdlog,
1424 "gdbarch_update: info.byte_order %d (%s)\n",
1426 (info.byte_order == BIG_ENDIAN ? "big"
1427 : info.byte_order == LITTLE_ENDIAN ? "little"
1429 fprintf_unfiltered (gdb_stdlog,
1430 "gdbarch_update: info.abfd 0x%lx\n",
1432 fprintf_unfiltered (gdb_stdlog,
1433 "gdbarch_update: info.tdep_info 0x%lx\n",
1434 (long) info.tdep_info);
1437 /* Ask the target for a replacement architecture. */
1438 new_gdbarch = rego->init (info, rego->arches);
1440 /* Did the target like it? No. Reject the change. */
1441 if (new_gdbarch == NULL)
1444 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1448 /* Did the architecture change? No. Do nothing. */
1449 if (current_gdbarch == new_gdbarch)
1452 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1454 new_gdbarch->bfd_arch_info->printable_name);
1458 /* Swap all data belonging to the old target out */
1459 swapout_gdbarch_swap (current_gdbarch);
1461 /* Is this a pre-existing architecture? Yes. Swap it in. */
1462 for (list = ®o->arches;
1464 list = &(*list)->next)
1466 if ((*list)->gdbarch == new_gdbarch)
1469 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1471 new_gdbarch->bfd_arch_info->printable_name);
1472 current_gdbarch = new_gdbarch;
1473 swapin_gdbarch_swap (new_gdbarch);
1478 /* Append this new architecture to this targets list. */
1479 (*list) = XMALLOC (struct gdbarch_list);
1480 (*list)->next = NULL;
1481 (*list)->gdbarch = new_gdbarch;
1483 /* Switch to this new architecture. Dump it out. */
1484 current_gdbarch = new_gdbarch;
1487 fprintf_unfiltered (gdb_stdlog,
1488 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1490 new_gdbarch->bfd_arch_info->printable_name);
1494 /* Check that the newly installed architecture is valid. */
1495 verify_gdbarch (new_gdbarch);
1497 /* Initialize the per-architecture memory (swap) areas.
1498 CURRENT_GDBARCH must be update before these modules are
1500 init_gdbarch_swap (new_gdbarch);
1502 /* Initialize the per-architecture data-pointer of all parties that
1503 registered an interest in this architecture. CURRENT_GDBARCH
1504 must be updated before these modules are called. */
1505 init_gdbarch_data (new_gdbarch);
1512 /* Functions to manipulate the endianness of the target. */
1514 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1515 /* compat - Catch old targets that expect a selectable byte-order to
1516 default to BIG_ENDIAN */
1517 #ifndef TARGET_BYTE_ORDER_DEFAULT
1518 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1521 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1522 #ifndef TARGET_BYTE_ORDER_DEFAULT
1523 /* compat - Catch old non byte-order selectable targets that do not
1524 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1525 TARGET_BYTE_ORDER to be used as the default. For targets that
1526 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1527 below will get a strange compiler warning. */
1528 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1531 #ifndef TARGET_BYTE_ORDER_DEFAULT
1532 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1534 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1535 int target_byte_order_auto = 1;
1537 /* Chain containing the \"set endian\" commands. */
1538 static struct cmd_list_element *endianlist = NULL;
1540 /* Called by \`\`show endian''. */
1542 show_endian (char *args, int from_tty)
1545 (TARGET_BYTE_ORDER_AUTO
1546 ? "The target endianness is set automatically (currently %s endian)\n"
1547 : "The target is assumed to be %s endian\n");
1548 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1551 /* Called if the user enters \`\`set endian'' without an argument. */
1553 set_endian (char *args, int from_tty)
1555 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1556 show_endian (args, from_tty);
1559 /* Called by \`\`set endian big''. */
1561 set_endian_big (char *args, int from_tty)
1563 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1565 target_byte_order = BIG_ENDIAN;
1566 target_byte_order_auto = 0;
1569 struct gdbarch_info info;
1570 memset (&info, 0, sizeof info);
1571 info.byte_order = BIG_ENDIAN;
1572 gdbarch_update (info);
1577 printf_unfiltered ("Byte order is not selectable.");
1578 show_endian (args, from_tty);
1582 /* Called by \`\`set endian little''. */
1584 set_endian_little (char *args, int from_tty)
1586 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1588 target_byte_order = LITTLE_ENDIAN;
1589 target_byte_order_auto = 0;
1592 struct gdbarch_info info;
1593 memset (&info, 0, sizeof info);
1594 info.byte_order = LITTLE_ENDIAN;
1595 gdbarch_update (info);
1600 printf_unfiltered ("Byte order is not selectable.");
1601 show_endian (args, from_tty);
1605 /* Called by \`\`set endian auto''. */
1607 set_endian_auto (char *args, int from_tty)
1609 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1611 target_byte_order_auto = 1;
1615 printf_unfiltered ("Byte order is not selectable.");
1616 show_endian (args, from_tty);
1620 /* Set the endianness from a BFD. */
1622 set_endian_from_file (bfd *abfd)
1624 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1628 if (bfd_big_endian (abfd))
1631 want = LITTLE_ENDIAN;
1632 if (TARGET_BYTE_ORDER_AUTO)
1633 target_byte_order = want;
1634 else if (TARGET_BYTE_ORDER != want)
1635 warning ("%s endian file does not match %s endian target.",
1636 want == BIG_ENDIAN ? "big" : "little",
1637 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1641 if (bfd_big_endian (abfd)
1642 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1643 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1644 warning ("%s endian file does not match %s endian target.",
1645 bfd_big_endian (abfd) ? "big" : "little",
1646 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1652 /* Functions to manipulate the architecture of the target */
1654 enum set_arch { set_arch_auto, set_arch_manual };
1656 int target_architecture_auto = 1;
1657 extern const struct bfd_arch_info bfd_default_arch_struct;
1658 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1659 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1661 static void show_endian (char *, int);
1662 static void set_endian (char *, int);
1663 static void set_endian_big (char *, int);
1664 static void set_endian_little (char *, int);
1665 static void set_endian_auto (char *, int);
1666 static void set_endian_from_file (bfd *);
1667 static int arch_ok (const struct bfd_arch_info *arch);
1668 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1669 static void show_architecture (char *, int);
1670 static void set_architecture (char *, int);
1671 static void info_architecture (char *, int);
1672 static void set_architecture_from_file (bfd *);
1674 /* Do the real work of changing the current architecture */
1677 arch_ok (const struct bfd_arch_info *arch)
1679 /* Should be performing the more basic check that the binary is
1680 compatible with GDB. */
1681 /* Check with the target that the architecture is valid. */
1682 return (target_architecture_hook == NULL
1683 || target_architecture_hook (arch));
1687 set_arch (const struct bfd_arch_info *arch,
1693 if (!arch_ok (arch))
1694 warning ("Target may not support %s architecture",
1695 arch->printable_name);
1696 target_architecture = arch;
1698 case set_arch_manual:
1699 if (!arch_ok (arch))
1701 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1702 arch->printable_name);
1706 target_architecture_auto = 0;
1707 target_architecture = arch;
1715 /* Called if the user enters \`\`show architecture'' without an argument. */
1717 show_architecture (char *args, int from_tty)
1720 arch = TARGET_ARCHITECTURE->printable_name;
1721 if (target_architecture_auto)
1722 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1724 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1727 /* Called if the user enters \`\`set architecture'' with or without an
1730 set_architecture (char *args, int from_tty)
1734 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1736 else if (strcmp (args, "auto") == 0)
1738 target_architecture_auto = 1;
1740 else if (GDB_MULTI_ARCH)
1742 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1744 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1747 struct gdbarch_info info;
1748 memset (&info, 0, sizeof info);
1749 info.bfd_arch_info = arch;
1750 if (gdbarch_update (info))
1751 target_architecture_auto = 0;
1753 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1758 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1760 set_arch (arch, set_arch_manual);
1762 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1766 /* Called if the user enters \`\`info architecture'' without an argument. */
1768 info_architecture (char *args, int from_tty)
1770 enum bfd_architecture a;
1773 if (gdbarch_init_registrary != NULL)
1775 struct gdbarch_init_registration *rego;
1776 printf_filtered ("Available architectures are:\n");
1777 for (rego = gdbarch_init_registrary;
1781 const struct bfd_arch_info *ap;
1782 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1787 printf_filtered (" %s", ap->printable_name);
1791 printf_filtered ("\n");
1797 printf_filtered ("There are no available architectures.\n");
1801 printf_filtered ("Available architectures are:\n");
1802 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1804 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1809 printf_filtered (" %s", ap->printable_name);
1813 printf_filtered ("\n");
1818 /* Set the architecture from arch/machine */
1820 set_architecture_from_arch_mach (arch, mach)
1821 enum bfd_architecture arch;
1824 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1826 set_arch (wanted, set_arch_manual);
1828 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1831 /* Set the architecture from a BFD */
1833 set_architecture_from_file (bfd *abfd)
1835 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1836 if (target_architecture_auto)
1838 set_arch (wanted, set_arch_auto);
1840 else if (wanted != target_architecture)
1842 warning ("%s architecture file may be incompatible with %s target.",
1843 wanted->printable_name,
1844 target_architecture->printable_name);
1849 /* Misc helper functions for targets. */
1852 frame_num_args_unknown (fi)
1853 struct frame_info *fi;
1860 generic_register_convertible_not (num)
1868 /* Pointer to the target-dependent disassembly function. */
1869 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1870 disassemble_info tm_print_insn_info;
1874 /* Set the dynamic target-system-dependant parameters (architecture,
1875 byte-order) using information found in the BFD */
1878 set_gdbarch_from_file (abfd)
1883 struct gdbarch_info info;
1884 memset (&info, 0, sizeof info);
1886 gdbarch_update (info);
1889 set_architecture_from_file (abfd);
1890 set_endian_from_file (abfd);
1894 #if defined (CALL_DUMMY)
1895 /* FIXME - this should go away */
1896 LONGEST call_dummy_words[] = CALL_DUMMY;
1897 int sizeof_call_dummy_words = sizeof (call_dummy_words);
1901 /* Initialize the current architecture. */
1903 initialize_current_architecture ()
1907 struct gdbarch_init_registration *rego;
1908 const struct bfd_arch_info *chosen = NULL;
1909 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
1911 const struct bfd_arch_info *ap
1912 = bfd_lookup_arch (rego->bfd_architecture, 0);
1914 /* Choose the first architecture alphabetically. */
1916 || strcmp (ap->printable_name, chosen->printable_name) < 0)
1922 struct gdbarch_info info;
1923 memset (&info, 0, sizeof info);
1924 info.bfd_arch_info = chosen;
1925 gdbarch_update (info);
1930 extern void _initialize_gdbarch (void);
1932 _initialize_gdbarch ()
1934 add_prefix_cmd ("endian", class_support, set_endian,
1935 "Set endianness of target.",
1936 &endianlist, "set endian ", 0, &setlist);
1937 add_cmd ("big", class_support, set_endian_big,
1938 "Set target as being big endian.", &endianlist);
1939 add_cmd ("little", class_support, set_endian_little,
1940 "Set target as being little endian.", &endianlist);
1941 add_cmd ("auto", class_support, set_endian_auto,
1942 "Select target endianness automatically.", &endianlist);
1943 add_cmd ("endian", class_support, show_endian,
1944 "Show endianness of target.", &showlist);
1946 add_cmd ("architecture", class_support, set_architecture,
1947 "Set architecture of target.", &setlist);
1948 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
1949 add_cmd ("architecture", class_support, show_architecture,
1950 "Show architecture of target.", &showlist);
1951 add_cmd ("architecture", class_support, info_architecture,
1952 "List supported target architectures", &infolist);
1954 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1955 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1956 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1957 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1958 tm_print_insn_info.print_address_func = dis_asm_print_address;
1960 add_show_from_set (add_set_cmd ("archdebug",
1963 (char *)&gdbarch_debug,
1964 "Set architecture debugging.\n\\
1965 When non-zero, architecture debugging is enabled.", &setlist),
1972 #../move-if-change new-gdbarch.c gdbarch.c
1973 if ! test -r gdbarch.c
1975 echo "gdbarch.c missing? cp new-gdbarch.c gdbarch.c" 1>&2
1976 elif diff -c gdbarch.c new-gdbarch.c
1978 echo "gdbarch.c unchanged" 1>&2
1980 echo "gdbarch.c has changed? cp new-gdbarch.c gdbarch.c" 1>&2