3 # Architecture commands for GDB, the GNU debugger.
4 # Copyright 1998-2000 Free Software Foundation, Inc.
6 # This file is part of GDB.
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 echo "${file} missing? cp new-${file} ${file}" 1>&2
28 elif diff -c ${file} new-
${file}
30 echo "${file} unchanged" 1>&2
32 echo "${file} has changed? cp new-${file} ${file}" 1>&2
37 # DEFAULT is a valid fallback definition of a MACRO when
38 # multi-arch is not enabled.
39 default_is_fallback_p
()
41 [ "${default}" != "" -a "${invalid_p}" = "0" ]
42 # FIXME: cagney - not until after 5.0
46 # Format of the input table
47 read="class level macro returntype function formal actual attrib startup default invalid_p fmt print print_p description"
53 test "${startup}" || startup
=0
54 test "${fmt}" ||
fmt="%ld"
55 test "${print}" || print
="(long) ${macro}"
56 #test "${default}" || default=0
64 # dump out/verify the doco
77 # hiding something from the ``struct info'' object
81 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
82 # LEVEL is a predicate on checking that a given method is
83 # initialized (using INVALID_P).
87 # The name of the MACRO that this method is to be accessed by.
91 # For functions, the return type; for variables, the data type
95 # For functions, the member function name; for variables, the
96 # variable name. Member function names are always prefixed with
97 # ``gdbarch_'' for name-space purity.
101 # The formal argument list. It is assumed that the formal
102 # argument list includes the actual name of each list element.
103 # A function with no arguments shall have ``void'' as the
104 # formal argument list.
108 # The list of actual arguments. The arguments specified shall
109 # match the FORMAL list given above. Functions with out
110 # arguments leave this blank.
114 # Any GCC attributes that should be attached to the function
115 # declaration. At present this field is unused.
119 # To help with the GDB startup a static gdbarch object is
120 # created. STARTUP is the value to insert into that static
123 # By default ``0'' is used.
127 # Any initial value to assign to a new gdbarch object after it
128 # as been malloc()ed. Zero is used by default.
130 # Specify a non-empty DEFAULT and a zero INVALID_P to create a
131 # fallback value or function for when multi-arch is disabled.
132 # Specify a zero DEFAULT function to make that fallback
137 # A predicate equation that validates MEMBER. Non-zero is
138 # returned if the code creating the new architecture failed to
139 # initialize the MEMBER or initialized the member to something
140 # invalid. By default, a check that the value is no longer
141 # equal to DEFAULT ips performed. The equation ``0'' disables
142 # the invalid_p check.
146 # printf style format string that can be used to print out the
147 # MEMBER. Sometimes "%s" is useful. For functions, this is
148 # ignored and the function address is printed.
150 # By default ```%ld'' is used.
154 # An optional equation that casts MEMBER to a value suitable
155 # for formatting by FMT.
157 # By default ``(long)'' is used.
161 # An optional indicator for any predicte to wrap around the
164 # # -> Wrap print up in ``#ifdef MACRO''
165 # exp -> Wrap print up in ``if (${print_p}) ...
166 # ``'' -> No predicate
180 # See below (DOCO) for description of each field
182 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct:::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
184 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
186 v:1:TARGET_BFD_VMA_BIT:int:bfd_vma_bit::::8 * sizeof (void*):TARGET_ARCHITECTURE->bits_per_address:0
187 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
188 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
189 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
190 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
191 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
192 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
193 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
194 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
195 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
197 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
198 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
199 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
200 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
201 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
202 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
204 v:2:NUM_REGS:int:num_regs::::0:-1
205 v:2:SP_REGNUM:int:sp_regnum::::0:-1
206 v:2:FP_REGNUM:int:fp_regnum::::0:-1
207 v:2:PC_REGNUM:int:pc_regnum::::0:-1
208 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr:::legacy_register_name:0
209 v:2:REGISTER_SIZE:int:register_size::::0:-1
210 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
211 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
212 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
213 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
214 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
215 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
216 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
218 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
219 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
220 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:
221 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1::0x%08lx
222 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::0x%08lx
223 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
224 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
225 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
226 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
227 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words:0:0x%08lx
228 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words:0:0x%08lx
229 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1::0x%08lx
230 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
231 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
233 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::0:::::#
234 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::0:::::#
235 f:2:COERCE_FLOAT_TO_DOUBLE:int:coerce_float_to_double:struct type *formal, struct type *actual:formal, actual:::default_coerce_float_to_double:0
236 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
238 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr:::generic_register_convertible_not:0
239 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
240 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
242 f:2:POINTER_TO_ADDRESS:CORE_ADDR:pointer_to_address:struct type *type, char *buf:type, buf:::generic_pointer_to_address:0
243 f:2:ADDRESS_TO_POINTER:void:address_to_pointer:struct type *type, char *buf, CORE_ADDR addr:type, buf, addr:::generic_address_to_pointer:0
245 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
246 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
247 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-:::0
248 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp:::0
249 f:2:POP_FRAME:void:pop_frame:void:-:::0
251 # I wish that these would just go away....
252 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x:::0:0
253 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x:::0:0
254 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x:::0
255 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x:::0
256 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x:::0
257 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x:::0
259 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp:::0
260 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf:::0
261 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf:::0
262 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type:::0
264 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
265 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame:::0
267 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
268 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
269 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr:::legacy_breakpoint_from_pc:0
270 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint:0
271 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint:0
272 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
273 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
275 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:::generic_remote_translate_xfer_address:0
277 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
278 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not:0
279 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
280 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
281 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
282 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
283 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
284 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
285 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
296 function_list |
while do_read
# eval read $read
299 ${class} ${macro}(${actual})
300 ${returntype} ${function} ($formal)${attrib}
304 invalid_p=${invalid_p}
308 description=${description}
317 /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */
319 /* Dynamic architecture support for GDB, the GNU debugger.
320 Copyright 1998-1999, Free Software Foundation, Inc.
322 This file is part of GDB.
324 This program is free software; you can redistribute it and/or modify
325 it under the terms of the GNU General Public License as published by
326 the Free Software Foundation; either version 2 of the License, or
327 (at your option) any later version.
329 This program is distributed in the hope that it will be useful,
330 but WITHOUT ANY WARRANTY; without even the implied warranty of
331 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
332 GNU General Public License for more details.
334 You should have received a copy of the GNU General Public License
335 along with this program; if not, write to the Free Software
336 Foundation, Inc., 59 Temple Place - Suite 330,
337 Boston, MA 02111-1307, USA. */
339 /* This file was created with the aid of \`\`gdbarch.sh''.
341 The bourn shell script \`\`gdbarch.sh'' creates the files
342 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
343 against the existing \`\`gdbarch.[hc]''. Any differences found
346 If editing this file, please also run gdbarch.sh and merge any
347 changes into that script. Conversely, when makeing sweeping changes
348 to this file, modifying gdbarch.sh and using its output may prove
368 #ifndef GDB_MULTI_ARCH
369 #define GDB_MULTI_ARCH 0
372 extern struct gdbarch *current_gdbarch;
375 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
379 /* If any of the following are defined, the target wasn't correctly
383 #if defined (CALL_DUMMY)
384 #error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
389 #if defined (REGISTER_NAMES)
390 #error "REGISTER_NAMES: replaced by REGISTER_NAME"
395 #if defined (EXTRA_FRAME_INFO)
396 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
401 #if defined (FRAME_FIND_SAVED_REGS)
402 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
410 echo "/* The following are pre-initialized by GDBARCH. */"
411 function_list |
while do_read
# eval read $read
416 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
417 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
418 echo "#if GDB_MULTI_ARCH"
419 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
420 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
430 echo "/* The following are initialized by the target dependant code. */"
431 function_list |
while do_read
# eval read $read
436 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
437 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
438 echo "#if GDB_MULTI_ARCH"
439 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
440 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
446 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
447 if [ "${formal}" = "void" ]
449 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
451 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
453 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
454 if ! default_is_fallback_p
456 echo "#if GDB_MULTI_ARCH"
458 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
459 if [ "${actual}" = "" ]
461 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
462 elif [ "${actual}" = "-" ]
464 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
466 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
469 if ! default_is_fallback_p
480 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
483 /* Mechanism for co-ordinating the selection of a specific
486 GDB targets (*-tdep.c) can register an interest in a specific
487 architecture. Other GDB components can register a need to maintain
488 per-architecture data.
490 The mechanisms below ensures that there is only a loose connection
491 between the set-architecture command and the various GDB
492 components. Each component can independantly register their need
493 to maintain architecture specific data with gdbarch.
497 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
500 The more traditional mega-struct containing architecture specific
501 data for all the various GDB components was also considered. Since
502 GDB is built from a variable number of (fairly independant)
503 components it was determined that the global aproach was not
507 /* Register a new architectural family with GDB.
509 Register support for the specified ARCHITECTURE with GDB. When
510 gdbarch determines that the specified architecture has been
511 selected, the corresponding INIT function is called.
515 The INIT function takes two parameters: INFO which contains the
516 information available to gdbarch about the (possibly new)
517 architecture; ARCHES which is a list of the previously created
518 \`\`struct gdbarch'' for this architecture.
520 The INIT function parameter INFO shall, as far as possible, be
521 pre-initialized with information obtained from INFO.ABFD or
522 previously selected architecture (if similar). INIT shall ensure
523 that the INFO.BYTE_ORDER is non-zero.
525 The INIT function shall return any of: NULL - indicating that it
526 doesn't reconize the selected architecture; an existing \`\`struct
527 gdbarch'' from the ARCHES list - indicating that the new
528 architecture is just a synonym for an earlier architecture (see
529 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
530 - that describes the selected architecture (see
535 struct gdbarch *gdbarch;
536 struct gdbarch_list *next;
541 /* Use default: bfd_arch_unknown (ZERO). */
542 enum bfd_architecture bfd_architecture;
544 /* Use default: NULL (ZERO). */
545 const struct bfd_arch_info *bfd_arch_info;
547 /* Use default: 0 (ZERO). */
550 /* Use default: NULL (ZERO). */
553 /* Use default: NULL (ZERO). */
554 struct gdbarch_tdep_info *tdep_info;
557 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
559 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
562 /* Helper function. Search the list of ARCHES for a GDBARCH that
563 matches the information provided by INFO. */
565 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
568 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
569 basic initialization using values obtained from the INFO andTDEP
570 parameters. set_gdbarch_*() functions are called to complete the
571 initialization of the object. */
573 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
576 /* Helper function. Free a partially-constructed \`\`struct gdbarch''. */
577 extern void gdbarch_free (struct gdbarch *);
580 /* Helper function. Force an update of the current architecture. Used
581 by legacy targets that have added their own target specific
582 architecture manipulation commands.
584 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
585 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
586 called. gdbarch_update() shall initialize any \`\`default'' fields
587 using information obtained from the previous architecture or
588 INFO.ABFD (if specified) before calling the corresponding
589 architectures INIT function. */
591 extern int gdbarch_update (struct gdbarch_info info);
595 /* Register per-architecture data-pointer.
597 Reserve space for a per-architecture data-pointer. An identifier
598 for the reserved data-pointer is returned. That identifer should
599 be saved in a local static.
601 When a new architecture is selected, INIT() is called. When a
602 previous architecture is re-selected, the per-architecture
603 data-pointer for that previous architecture is restored (INIT() is
606 INIT() shall return the initial value for the per-architecture
607 data-pointer for the current architecture.
609 Multiple registrarants for any architecture are allowed (and
610 strongly encouraged). */
612 typedef void *(gdbarch_data_ftype) (void);
613 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
615 /* Return the value of the per-architecture data-pointer for the
616 current architecture. */
618 extern void *gdbarch_data (struct gdbarch_data*);
622 /* Register per-architecture memory region.
624 Provide a memory-region swap mechanism. Per-architecture memory
625 region are created. These memory regions are swapped whenever the
626 architecture is changed. For a new architecture, the memory region
627 is initialized with zero (0) and the INIT function is called.
629 Memory regions are swapped / initialized in the order that they are
630 registered. NULL DATA and/or INIT values can be specified.
632 New code should use register_gdbarch_data(). */
634 typedef void (gdbarch_swap_ftype) (void);
635 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
636 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
640 /* The target-system-dependant byte order is dynamic */
642 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
643 is selectable at runtime. The user can use the \`\`set endian''
644 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
645 target_byte_order should be auto-detected (from the program image
649 /* Multi-arch GDB is always bi-endian. */
650 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
653 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
654 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
655 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
656 #ifdef TARGET_BYTE_ORDER_SELECTABLE
657 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
659 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
663 extern int target_byte_order;
664 #ifdef TARGET_BYTE_ORDER_SELECTABLE
665 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
666 and expect defs.h to re-define TARGET_BYTE_ORDER. */
667 #undef TARGET_BYTE_ORDER
669 #ifndef TARGET_BYTE_ORDER
670 #define TARGET_BYTE_ORDER (target_byte_order + 0)
673 extern int target_byte_order_auto;
674 #ifndef TARGET_BYTE_ORDER_AUTO
675 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
680 /* The target-system-dependant BFD architecture is dynamic */
682 extern int target_architecture_auto;
683 #ifndef TARGET_ARCHITECTURE_AUTO
684 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
687 extern const struct bfd_arch_info *target_architecture;
688 #ifndef TARGET_ARCHITECTURE
689 #define TARGET_ARCHITECTURE (target_architecture + 0)
692 /* Notify the target dependant backend of a change to the selected
693 architecture. A zero return status indicates that the target did
694 not like the change. */
696 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
700 /* The target-system-dependant disassembler is semi-dynamic */
702 #include "dis-asm.h" /* Get defs for disassemble_info */
704 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
705 unsigned int len, disassemble_info *info);
707 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
708 disassemble_info *info);
710 extern void dis_asm_print_address (bfd_vma addr,
711 disassemble_info *info);
713 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
714 extern disassemble_info tm_print_insn_info;
715 #ifndef TARGET_PRINT_INSN
716 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
718 #ifndef TARGET_PRINT_INSN_INFO
719 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
724 /* Explicit test for D10V architecture.
725 USE of these macro's is *STRONGLY* discouraged. */
727 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
728 #ifndef D10V_MAKE_DADDR
729 #define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
731 #ifndef D10V_MAKE_IADDR
732 #define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
736 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
737 #ifndef FRAMELESS_FUNCTION_INVOCATION
738 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
742 /* Fallback definition of REGISTER_CONVERTIBLE etc */
743 extern int generic_register_convertible_not (int reg_nr);
744 #ifndef REGISTER_CONVERTIBLE
745 #define REGISTER_CONVERTIBLE(x) (0)
747 #ifndef REGISTER_CONVERT_TO_VIRTUAL
748 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
750 #ifndef REGISTER_CONVERT_TO_RAW
751 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
755 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
756 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
757 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
758 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
760 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
761 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
766 /* Fallback definition for REGISTER_NAME for systems still defining
768 #ifndef REGISTER_NAME
769 extern char *gdb_register_names[];
770 #define REGISTER_NAME(i) gdb_register_names[i]
774 /* Set the dynamic target-system-dependant parameters (architecture,
775 byte-order, ...) using information found in the BFD */
777 extern void set_gdbarch_from_file (bfd *);
780 /* Explicitly set the dynamic target-system-dependant parameters based
781 on bfd_architecture and machine. */
783 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
786 /* Initialize the current architecture to the "first" one we find on
789 extern void initialize_current_architecture (void);
791 /* Helper function for targets that don't know how my arguments are
794 extern int frame_num_args_unknown (struct frame_info *fi);
797 /* gdbarch trace variable */
798 extern int gdbarch_debug;
800 extern void gdbarch_dump (void);
805 #../move-if-change new-gdbarch.h gdbarch.h
806 compare_new gdbarch.h
818 #include "gdbarch-utils.h"
822 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
824 /* Just include everything in sight so that the every old definition
825 of macro is visible. */
826 #include "gdb_string.h"
830 #include "inferior.h"
831 #include "breakpoint.h"
832 #include "gdb_wait.h"
836 #include "gdbthread.h"
837 #include "annotate.h"
838 #include "symfile.h" /* for overlay functions */
843 /* Static function declarations */
845 static void verify_gdbarch (struct gdbarch *gdbarch);
846 static void init_gdbarch_data (struct gdbarch *);
847 static void init_gdbarch_swap (struct gdbarch *);
848 static void swapout_gdbarch_swap (struct gdbarch *);
849 static void swapin_gdbarch_swap (struct gdbarch *);
851 /* Convenience macro for allocting typesafe memory. */
854 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
858 /* Non-zero if we want to trace architecture code. */
860 #ifndef GDBARCH_DEBUG
861 #define GDBARCH_DEBUG 0
863 int gdbarch_debug = GDBARCH_DEBUG;
867 # gdbarch open the gdbarch object
869 echo "/* Maintain the struct gdbarch object */"
871 echo "struct gdbarch"
873 echo " /* basic architectural information */"
874 function_list |
while do_read
# eval read $read
877 "i" ) echo " ${returntype} ${function};" ;;
881 echo " /* target specific vector. */"
882 echo " struct gdbarch_tdep *tdep;"
884 echo " /* per-architecture data-pointers */"
888 echo " /* per-architecture swap-regions */"
889 echo " struct gdbarch_swap *swap;"
892 /* Multi-arch values.
894 When extending this structure you must:
898 Declare set/get functions and define the corresponding
901 gdbarch_alloc(): If zero/NULL is not a suitable default,
902 initialize the new field.
904 verify_gdbarch(): Confirm that the target updated the field
907 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
910 \`\`startup_gdbarch()'': Append an initial value to the static
911 variable (base values on the host's c-type system).
913 get_gdbarch(): Implement the set/get functions (probably using
914 the macro's as shortcuts).
919 function_list |
while do_read
# eval read $read
922 "v" ) echo " ${returntype} ${function};" ;;
923 "f" ) echo " gdbarch_${function}_ftype *${function}${attrib};" ;;
928 # A pre-initialized vector
932 /* The default architecture uses host values (for want of a better
936 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
938 echo "struct gdbarch startup_gdbarch = {"
939 echo " /* basic architecture information */"
940 function_list |
while do_read
# eval read $read
949 /* target specific vector */
951 /*per-architecture data-pointers and swap regions */
953 /* Multi-arch values */
955 function_list |
while do_read
# eval read $read
964 /* startup_gdbarch() */
966 struct gdbarch *current_gdbarch = &startup_gdbarch;
969 # Create a new gdbarch struct
973 /* Create a new \`\`struct gdbarch'' based in information provided by
974 \`\`struct gdbarch_info''. */
979 gdbarch_alloc (const struct gdbarch_info *info,
980 struct gdbarch_tdep *tdep)
982 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
983 memset (gdbarch, 0, sizeof (*gdbarch));
985 gdbarch->tdep = tdep;
988 function_list |
while do_read
# eval read $read
991 "i" ) echo " gdbarch->${function} = info->${function};"
995 echo " /* Force the explicit initialization of these. */"
996 function_list |
while do_read
# eval read $read
1000 if [ "${default}" != "" -a "${default}" != "0" ]
1002 echo " gdbarch->${function} = ${default};"
1008 /* gdbarch_alloc() */
1014 # Free a gdbarch struct.
1018 /* Free a gdbarch struct. This should never happen in normal
1019 operation --- once you've created a gdbarch, you keep it around.
1020 However, if an architecture's init function encounters an error
1021 building the structure, it may need to clean up a partially
1022 constructed gdbarch. */
1024 gdbarch_free (struct gdbarch *arch)
1026 /* At the moment, this is trivial. */
1031 # verify a new architecture
1034 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
1038 verify_gdbarch (struct gdbarch *gdbarch)
1040 /* Only perform sanity checks on a multi-arch target. */
1041 if (GDB_MULTI_ARCH <= 0)
1044 if (gdbarch->byte_order == 0)
1045 internal_error ("verify_gdbarch: byte-order unset");
1046 if (gdbarch->bfd_arch_info == NULL)
1047 internal_error ("verify_gdbarch: bfd_arch_info unset");
1048 /* Check those that need to be defined for the given multi-arch level. */
1050 function_list |
while do_read
# eval read $read
1054 if [ "${invalid_p}" = "0" ]
1056 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1057 elif [ "${invalid_p}" ]
1059 echo " if ((GDB_MULTI_ARCH >= ${level})"
1060 echo " && (${invalid_p}))"
1061 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1062 elif [ "${default}" ]
1064 echo " if ((GDB_MULTI_ARCH >= ${level})"
1065 echo " && (gdbarch->${function} == ${default}))"
1066 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
1075 # dump the structure
1078 echo "/* Print out the details of the current architecture. */"
1085 function_list |
while do_read
# eval read $read
1089 echo " fprintf_unfiltered (gdb_stdlog,"
1090 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1091 echo " (long) current_gdbarch->${function}"
1092 echo " /*${macro} ()*/);"
1095 if [ "${print_p}" = "#" ]
1097 echo "#ifdef ${macro}"
1098 echo " fprintf_unfiltered (gdb_stdlog,"
1099 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1102 elif [ "${print_p}" ]
1104 echo " if (${print_p})"
1105 echo " fprintf_unfiltered (gdb_stdlog,"
1106 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1109 echo " fprintf_unfiltered (gdb_stdlog,"
1110 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1122 struct gdbarch_tdep *
1123 gdbarch_tdep (struct gdbarch *gdbarch)
1125 if (gdbarch_debug >= 2)
1126 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1127 return gdbarch->tdep;
1131 function_list |
while do_read
# eval read $read
1136 echo "${returntype}"
1137 if [ "${formal}" = "void" ]
1139 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1141 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1144 if default_is_fallback_p
&& [ "${default}" != "0" ]
1146 echo " if (GDB_MULTI_ARCH == 0)"
1147 if [ "${returntype}" = "void" ]
1150 echo " ${default} (${actual});"
1154 echo " return ${default} (${actual});"
1157 echo " if (gdbarch->${function} == 0)"
1158 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1159 echo " if (gdbarch_debug >= 2)"
1160 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1161 test "${actual}" = "-" && actual
=""
1162 if [ "${returntype}" = "void" ]
1164 echo " gdbarch->${function} (${actual});"
1166 echo " return gdbarch->${function} (${actual});"
1171 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1172 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1174 echo " gdbarch->${function} = ${function};"
1179 echo "${returntype}"
1180 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1182 if [ "${invalid_p}" = "0" ]
1184 echo " /* Skip verify of ${function}, invalid_p == 0 */"
1185 elif [ "${invalid_p}" ]
1187 echo " if (${invalid_p})"
1188 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1189 elif [ "${default}" ]
1191 echo " if (gdbarch->${function} == ${default})"
1192 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1194 echo " if (gdbarch_debug >= 2)"
1195 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1196 echo " return gdbarch->${function};"
1200 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1201 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1203 echo " gdbarch->${function} = ${function};"
1208 echo "${returntype}"
1209 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1211 echo " if (gdbarch_debug >= 2)"
1212 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1213 echo " return gdbarch->${function};"
1219 # All the trailing guff
1223 /* Keep a registrary of per-architecture data-pointers required by GDB
1231 struct gdbarch_data_registration
1233 gdbarch_data_ftype *init;
1234 struct gdbarch_data *data;
1235 struct gdbarch_data_registration *next;
1238 struct gdbarch_data_registrary
1241 struct gdbarch_data_registration *registrations;
1244 struct gdbarch_data_registrary gdbarch_data_registrary =
1249 struct gdbarch_data *
1250 register_gdbarch_data (gdbarch_data_ftype *init)
1252 struct gdbarch_data_registration **curr;
1253 for (curr = &gdbarch_data_registrary.registrations;
1255 curr = &(*curr)->next);
1256 (*curr) = XMALLOC (struct gdbarch_data_registration);
1257 (*curr)->next = NULL;
1258 (*curr)->init = init;
1259 (*curr)->data = XMALLOC (struct gdbarch_data);
1260 (*curr)->data->index = gdbarch_data_registrary.nr++;
1261 return (*curr)->data;
1265 /* Walk through all the registered users initializing each in turn. */
1268 init_gdbarch_data (struct gdbarch *gdbarch)
1270 struct gdbarch_data_registration *rego;
1271 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1272 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1273 for (rego = gdbarch_data_registrary.registrations;
1277 if (rego->data->index < gdbarch->nr_data)
1278 gdbarch->data[rego->data->index] = rego->init ();
1283 /* Return the current value of the specified per-architecture
1288 struct gdbarch_data *data;
1290 if (data->index >= current_gdbarch->nr_data)
1291 internal_error ("gdbarch_data: request for non-existant data.");
1292 return current_gdbarch->data[data->index];
1297 /* Keep a registrary of swaped data required by GDB modules. */
1302 struct gdbarch_swap_registration *source;
1303 struct gdbarch_swap *next;
1306 struct gdbarch_swap_registration
1309 unsigned long sizeof_data;
1310 gdbarch_swap_ftype *init;
1311 struct gdbarch_swap_registration *next;
1314 struct gdbarch_swap_registrary
1317 struct gdbarch_swap_registration *registrations;
1320 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1326 register_gdbarch_swap (void *data,
1327 unsigned long sizeof_data,
1328 gdbarch_swap_ftype *init)
1330 struct gdbarch_swap_registration **rego;
1331 for (rego = &gdbarch_swap_registrary.registrations;
1333 rego = &(*rego)->next);
1334 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1335 (*rego)->next = NULL;
1336 (*rego)->init = init;
1337 (*rego)->data = data;
1338 (*rego)->sizeof_data = sizeof_data;
1343 init_gdbarch_swap (struct gdbarch *gdbarch)
1345 struct gdbarch_swap_registration *rego;
1346 struct gdbarch_swap **curr = &gdbarch->swap;
1347 for (rego = gdbarch_swap_registrary.registrations;
1351 if (rego->data != NULL)
1353 (*curr) = XMALLOC (struct gdbarch_swap);
1354 (*curr)->source = rego;
1355 (*curr)->swap = xmalloc (rego->sizeof_data);
1356 (*curr)->next = NULL;
1357 memset (rego->data, 0, rego->sizeof_data);
1358 curr = &(*curr)->next;
1360 if (rego->init != NULL)
1366 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1368 struct gdbarch_swap *curr;
1369 for (curr = gdbarch->swap;
1372 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1376 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1378 struct gdbarch_swap *curr;
1379 for (curr = gdbarch->swap;
1382 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1386 /* Keep a registrary of the architectures known by GDB. */
1388 struct gdbarch_init_registration
1390 enum bfd_architecture bfd_architecture;
1391 gdbarch_init_ftype *init;
1392 struct gdbarch_list *arches;
1393 struct gdbarch_init_registration *next;
1396 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1399 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1400 gdbarch_init_ftype *init)
1402 struct gdbarch_init_registration **curr;
1403 const struct bfd_arch_info *bfd_arch_info;
1404 /* Check that BFD reconizes this architecture */
1405 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1406 if (bfd_arch_info == NULL)
1408 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1410 /* Check that we haven't seen this architecture before */
1411 for (curr = &gdbarch_init_registrary;
1413 curr = &(*curr)->next)
1415 if (bfd_architecture == (*curr)->bfd_architecture)
1416 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1417 bfd_arch_info->printable_name);
1421 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1422 bfd_arch_info->printable_name,
1425 (*curr) = XMALLOC (struct gdbarch_init_registration);
1426 (*curr)->bfd_architecture = bfd_architecture;
1427 (*curr)->init = init;
1428 (*curr)->arches = NULL;
1429 (*curr)->next = NULL;
1434 /* Look for an architecture using gdbarch_info. Base search on only
1435 BFD_ARCH_INFO and BYTE_ORDER. */
1437 struct gdbarch_list *
1438 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1439 const struct gdbarch_info *info)
1441 for (; arches != NULL; arches = arches->next)
1443 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1445 if (info->byte_order != arches->gdbarch->byte_order)
1453 /* Update the current architecture. Return ZERO if the update request
1457 gdbarch_update (struct gdbarch_info info)
1459 struct gdbarch *new_gdbarch;
1460 struct gdbarch_list **list;
1461 struct gdbarch_init_registration *rego;
1463 /* Fill in any missing bits. Most important is the bfd_architecture
1464 which is used to select the target architecture. */
1465 if (info.bfd_architecture == bfd_arch_unknown)
1467 if (info.bfd_arch_info != NULL)
1468 info.bfd_architecture = info.bfd_arch_info->arch;
1469 else if (info.abfd != NULL)
1470 info.bfd_architecture = bfd_get_arch (info.abfd);
1471 /* FIXME - should query BFD for its default architecture. */
1473 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1475 if (info.bfd_arch_info == NULL)
1477 if (target_architecture_auto && info.abfd != NULL)
1478 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1480 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1482 if (info.byte_order == 0)
1484 if (target_byte_order_auto && info.abfd != NULL)
1485 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1486 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1489 info.byte_order = current_gdbarch->byte_order;
1490 /* FIXME - should query BFD for its default byte-order. */
1492 /* A default for abfd? */
1494 /* Find the target that knows about this architecture. */
1495 for (rego = gdbarch_init_registrary;
1496 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1501 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1507 fprintf_unfiltered (gdb_stdlog,
1508 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1509 info.bfd_architecture,
1510 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1511 fprintf_unfiltered (gdb_stdlog,
1512 "gdbarch_update: info.bfd_arch_info %s\n",
1513 (info.bfd_arch_info != NULL
1514 ? info.bfd_arch_info->printable_name
1516 fprintf_unfiltered (gdb_stdlog,
1517 "gdbarch_update: info.byte_order %d (%s)\n",
1519 (info.byte_order == BIG_ENDIAN ? "big"
1520 : info.byte_order == LITTLE_ENDIAN ? "little"
1522 fprintf_unfiltered (gdb_stdlog,
1523 "gdbarch_update: info.abfd 0x%lx\n",
1525 fprintf_unfiltered (gdb_stdlog,
1526 "gdbarch_update: info.tdep_info 0x%lx\n",
1527 (long) info.tdep_info);
1530 /* Ask the target for a replacement architecture. */
1531 new_gdbarch = rego->init (info, rego->arches);
1533 /* Did the target like it? No. Reject the change. */
1534 if (new_gdbarch == NULL)
1537 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1541 /* Did the architecture change? No. Do nothing. */
1542 if (current_gdbarch == new_gdbarch)
1545 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1547 new_gdbarch->bfd_arch_info->printable_name);
1551 /* Swap all data belonging to the old target out */
1552 swapout_gdbarch_swap (current_gdbarch);
1554 /* Is this a pre-existing architecture? Yes. Swap it in. */
1555 for (list = ®o->arches;
1557 list = &(*list)->next)
1559 if ((*list)->gdbarch == new_gdbarch)
1562 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1564 new_gdbarch->bfd_arch_info->printable_name);
1565 current_gdbarch = new_gdbarch;
1566 swapin_gdbarch_swap (new_gdbarch);
1571 /* Append this new architecture to this targets list. */
1572 (*list) = XMALLOC (struct gdbarch_list);
1573 (*list)->next = NULL;
1574 (*list)->gdbarch = new_gdbarch;
1576 /* Switch to this new architecture. Dump it out. */
1577 current_gdbarch = new_gdbarch;
1580 fprintf_unfiltered (gdb_stdlog,
1581 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1583 new_gdbarch->bfd_arch_info->printable_name);
1587 /* Check that the newly installed architecture is valid. */
1588 verify_gdbarch (new_gdbarch);
1590 /* Initialize the per-architecture memory (swap) areas.
1591 CURRENT_GDBARCH must be update before these modules are
1593 init_gdbarch_swap (new_gdbarch);
1595 /* Initialize the per-architecture data-pointer of all parties that
1596 registered an interest in this architecture. CURRENT_GDBARCH
1597 must be updated before these modules are called. */
1598 init_gdbarch_data (new_gdbarch);
1605 /* Functions to manipulate the endianness of the target. */
1607 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1608 /* compat - Catch old targets that expect a selectable byte-order to
1609 default to BIG_ENDIAN */
1610 #ifndef TARGET_BYTE_ORDER_DEFAULT
1611 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1614 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1615 #ifndef TARGET_BYTE_ORDER_DEFAULT
1616 /* compat - Catch old non byte-order selectable targets that do not
1617 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1618 TARGET_BYTE_ORDER to be used as the default. For targets that
1619 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1620 below will get a strange compiler warning. */
1621 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1624 #ifndef TARGET_BYTE_ORDER_DEFAULT
1625 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1627 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1628 int target_byte_order_auto = 1;
1630 /* Chain containing the \"set endian\" commands. */
1631 static struct cmd_list_element *endianlist = NULL;
1633 /* Called by \`\`show endian''. */
1635 show_endian (char *args, int from_tty)
1638 (TARGET_BYTE_ORDER_AUTO
1639 ? "The target endianness is set automatically (currently %s endian)\n"
1640 : "The target is assumed to be %s endian\n");
1641 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1644 /* Called if the user enters \`\`set endian'' without an argument. */
1646 set_endian (char *args, int from_tty)
1648 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1649 show_endian (args, from_tty);
1652 /* Called by \`\`set endian big''. */
1654 set_endian_big (char *args, int from_tty)
1656 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1658 target_byte_order = BIG_ENDIAN;
1659 target_byte_order_auto = 0;
1662 struct gdbarch_info info;
1663 memset (&info, 0, sizeof info);
1664 info.byte_order = BIG_ENDIAN;
1665 gdbarch_update (info);
1670 printf_unfiltered ("Byte order is not selectable.");
1671 show_endian (args, from_tty);
1675 /* Called by \`\`set endian little''. */
1677 set_endian_little (char *args, int from_tty)
1679 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1681 target_byte_order = LITTLE_ENDIAN;
1682 target_byte_order_auto = 0;
1685 struct gdbarch_info info;
1686 memset (&info, 0, sizeof info);
1687 info.byte_order = LITTLE_ENDIAN;
1688 gdbarch_update (info);
1693 printf_unfiltered ("Byte order is not selectable.");
1694 show_endian (args, from_tty);
1698 /* Called by \`\`set endian auto''. */
1700 set_endian_auto (char *args, int from_tty)
1702 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1704 target_byte_order_auto = 1;
1708 printf_unfiltered ("Byte order is not selectable.");
1709 show_endian (args, from_tty);
1713 /* Set the endianness from a BFD. */
1715 set_endian_from_file (bfd *abfd)
1717 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1721 if (bfd_big_endian (abfd))
1724 want = LITTLE_ENDIAN;
1725 if (TARGET_BYTE_ORDER_AUTO)
1726 target_byte_order = want;
1727 else if (TARGET_BYTE_ORDER != want)
1728 warning ("%s endian file does not match %s endian target.",
1729 want == BIG_ENDIAN ? "big" : "little",
1730 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1734 if (bfd_big_endian (abfd)
1735 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1736 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1737 warning ("%s endian file does not match %s endian target.",
1738 bfd_big_endian (abfd) ? "big" : "little",
1739 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1745 /* Functions to manipulate the architecture of the target */
1747 enum set_arch { set_arch_auto, set_arch_manual };
1749 int target_architecture_auto = 1;
1750 extern const struct bfd_arch_info bfd_default_arch_struct;
1751 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1752 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1754 static void show_endian (char *, int);
1755 static void set_endian (char *, int);
1756 static void set_endian_big (char *, int);
1757 static void set_endian_little (char *, int);
1758 static void set_endian_auto (char *, int);
1759 static void set_endian_from_file (bfd *);
1760 static int arch_ok (const struct bfd_arch_info *arch);
1761 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1762 static void show_architecture (char *, int);
1763 static void set_architecture (char *, int);
1764 static void info_architecture (char *, int);
1765 static void set_architecture_from_file (bfd *);
1767 /* Do the real work of changing the current architecture */
1770 arch_ok (const struct bfd_arch_info *arch)
1772 /* Should be performing the more basic check that the binary is
1773 compatible with GDB. */
1774 /* Check with the target that the architecture is valid. */
1775 return (target_architecture_hook == NULL
1776 || target_architecture_hook (arch));
1780 set_arch (const struct bfd_arch_info *arch,
1786 if (!arch_ok (arch))
1787 warning ("Target may not support %s architecture",
1788 arch->printable_name);
1789 target_architecture = arch;
1791 case set_arch_manual:
1792 if (!arch_ok (arch))
1794 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1795 arch->printable_name);
1799 target_architecture_auto = 0;
1800 target_architecture = arch;
1808 /* Called if the user enters \`\`show architecture'' without an argument. */
1810 show_architecture (char *args, int from_tty)
1813 arch = TARGET_ARCHITECTURE->printable_name;
1814 if (target_architecture_auto)
1815 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1817 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1820 /* Called if the user enters \`\`set architecture'' with or without an
1823 set_architecture (char *args, int from_tty)
1827 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1829 else if (strcmp (args, "auto") == 0)
1831 target_architecture_auto = 1;
1833 else if (GDB_MULTI_ARCH)
1835 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1837 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1840 struct gdbarch_info info;
1841 memset (&info, 0, sizeof info);
1842 info.bfd_arch_info = arch;
1843 if (gdbarch_update (info))
1844 target_architecture_auto = 0;
1846 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1851 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1853 set_arch (arch, set_arch_manual);
1855 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1859 /* Called if the user enters \`\`info architecture'' without an argument. */
1861 info_architecture (char *args, int from_tty)
1863 enum bfd_architecture a;
1866 if (gdbarch_init_registrary != NULL)
1868 struct gdbarch_init_registration *rego;
1869 printf_filtered ("Available architectures are:\n");
1870 for (rego = gdbarch_init_registrary;
1874 const struct bfd_arch_info *ap;
1875 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1880 printf_filtered (" %s", ap->printable_name);
1884 printf_filtered ("\n");
1890 printf_filtered ("There are no available architectures.\n");
1894 printf_filtered ("Available architectures are:\n");
1895 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1897 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1902 printf_filtered (" %s", ap->printable_name);
1906 printf_filtered ("\n");
1911 /* Set the architecture from arch/machine */
1913 set_architecture_from_arch_mach (arch, mach)
1914 enum bfd_architecture arch;
1917 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1919 set_arch (wanted, set_arch_manual);
1921 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1924 /* Set the architecture from a BFD */
1926 set_architecture_from_file (bfd *abfd)
1928 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1929 if (target_architecture_auto)
1931 set_arch (wanted, set_arch_auto);
1933 else if (wanted != target_architecture)
1935 warning ("%s architecture file may be incompatible with %s target.",
1936 wanted->printable_name,
1937 target_architecture->printable_name);
1942 /* Misc helper functions for targets. */
1945 frame_num_args_unknown (fi)
1946 struct frame_info *fi;
1953 generic_register_convertible_not (num)
1962 /* Pointer to the target-dependent disassembly function. */
1963 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1964 disassemble_info tm_print_insn_info;
1968 /* Set the dynamic target-system-dependant parameters (architecture,
1969 byte-order) using information found in the BFD */
1972 set_gdbarch_from_file (abfd)
1977 struct gdbarch_info info;
1978 memset (&info, 0, sizeof info);
1980 gdbarch_update (info);
1983 set_architecture_from_file (abfd);
1984 set_endian_from_file (abfd);
1988 #if defined (CALL_DUMMY)
1989 /* FIXME - this should go away */
1990 LONGEST call_dummy_words[] = CALL_DUMMY;
1991 int sizeof_call_dummy_words = sizeof (call_dummy_words);
1995 /* Initialize the current architecture. */
1997 initialize_current_architecture ()
2001 struct gdbarch_init_registration *rego;
2002 const struct bfd_arch_info *chosen = NULL;
2003 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
2005 const struct bfd_arch_info *ap
2006 = bfd_lookup_arch (rego->bfd_architecture, 0);
2008 /* Choose the first architecture alphabetically. */
2010 || strcmp (ap->printable_name, chosen->printable_name) < 0)
2016 struct gdbarch_info info;
2017 memset (&info, 0, sizeof info);
2018 info.bfd_arch_info = chosen;
2019 gdbarch_update (info);
2024 extern void _initialize_gdbarch (void);
2026 _initialize_gdbarch ()
2028 struct cmd_list_element *c;
2030 add_prefix_cmd ("endian", class_support, set_endian,
2031 "Set endianness of target.",
2032 &endianlist, "set endian ", 0, &setlist);
2033 add_cmd ("big", class_support, set_endian_big,
2034 "Set target as being big endian.", &endianlist);
2035 add_cmd ("little", class_support, set_endian_little,
2036 "Set target as being little endian.", &endianlist);
2037 add_cmd ("auto", class_support, set_endian_auto,
2038 "Select target endianness automatically.", &endianlist);
2039 add_cmd ("endian", class_support, show_endian,
2040 "Show endianness of target.", &showlist);
2042 add_cmd ("architecture", class_support, set_architecture,
2043 "Set architecture of target.", &setlist);
2044 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
2045 add_cmd ("architecture", class_support, show_architecture,
2046 "Show architecture of target.", &showlist);
2047 add_cmd ("architecture", class_support, info_architecture,
2048 "List supported target architectures", &infolist);
2050 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
2051 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
2052 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
2053 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
2054 tm_print_insn_info.print_address_func = dis_asm_print_address;
2056 add_show_from_set (add_set_cmd ("arch",
2059 (char *)&gdbarch_debug,
2060 "Set architecture debugging.\n\\
2061 When non-zero, architecture debugging is enabled.", &setdebuglist),
2063 c = add_set_cmd ("archdebug",
2066 (char *)&gdbarch_debug,
2067 "Set architecture debugging.\n\\
2068 When non-zero, architecture debugging is enabled.", &setlist);
2070 deprecate_cmd (c, "set debug arch");
2071 deprecate_cmd (add_show_from_set (c, &showlist), "show debug arch");
2077 #../move-if-change new-gdbarch.c gdbarch.c
2078 compare_new gdbarch.c
This page took 0.105571 seconds and 4 git commands to generate.