92f3170902049afa03bf6bebdd4ccb2e1f061bbf
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 init_p fmt print print_p description"
24 # dump out/verify the doco
36 # hiding something from the ``struct info'' object
40 # See GDB_MULTI_ARCH description. Having GDB_MULTI_ARCH >=
41 # LEVEL is a predicate on checking that a given method is
42 # initialized (using INIT_P).
46 # The name of the MACRO that this method is to be accessed by.
50 # For functions, the return type; for variables, the data type
54 # For functions, the member function name; for variables, the
55 # variable name. Member function names are always prefixed with
56 # ``gdbarch_'' for name-space purity.
60 # The formal argument list. It is assumed that the formal
61 # argument list includes the actual name of each list element.
62 # A function with no arguments shall have ``void'' as the formal
67 # The list of actual arguments. The arguments specified shall
68 # match the FORMAL list given above. Functions with out
69 # arguments leave this blank.
73 # Any GCC attributes that should be attached to the function
74 # declaration. At present this field is unused.
78 # To help with the GDB startup a default static gdbarch object
79 # is created. DEFAULT is the value to insert into that
80 # array. It defaults to ZERO.
84 # Any initial value to assign to the member after it is been
85 # MALLOCed. Defaults to zero.
89 # A predicate equation that tests to see if the code creating
90 # the new architecture has correctly updated this
91 # MEMBER. Default is to check that the value is no longer equal
96 # printf style format string that can be used to print out the
97 # MEMBER. The default is to assume "%ld" is safe. Sometimes
98 # "%s" is useful. For functions, this is ignored and the
99 # function address is printed.
103 # An optional equation that converts the MEMBER into a value
104 # suitable for that FMT. By default it is assumed that the
105 # member's MACRO cast to long is safe.
109 # An optional indicator for any predicte to wrap around the
111 # # -> Wrap print up in ``#ifdef MACRO''
112 # exp -> Wrap print up in ``if (${print_p}) ...
126 # See below (DOCO) for description of each field
128 i:2:TARGET_ARCHITECTURE:const struct bfd_arch_info *:bfd_arch_info::::&bfd_default_arch_struct:::%s:TARGET_ARCHITECTURE->printable_name:TARGET_ARCHITECTURE != NULL
130 i:2:TARGET_BYTE_ORDER:int:byte_order::::BIG_ENDIAN
132 v:1:TARGET_PTR_BIT:int:ptr_bit::::8 * sizeof (void*):0
133 #v:1:TARGET_CHAR_BIT:int:char_bit::::8 * sizeof (char):0
134 v:1:TARGET_SHORT_BIT:int:short_bit::::8 * sizeof (short):0
135 v:1:TARGET_INT_BIT:int:int_bit::::8 * sizeof (int):0
136 v:1:TARGET_LONG_BIT:int:long_bit::::8 * sizeof (long):0
137 v:1:TARGET_LONG_LONG_BIT:int:long_long_bit::::8 * sizeof (LONGEST):0
138 v:1:TARGET_FLOAT_BIT:int:float_bit::::8 * sizeof (float):0
139 v:1:TARGET_DOUBLE_BIT:int:double_bit::::8 * sizeof (double):0
140 v:1:TARGET_LONG_DOUBLE_BIT:int:long_double_bit::::8 * sizeof (long double):0
142 f:1:TARGET_READ_PC:CORE_ADDR:read_pc:int pid:pid::0:0
143 f:1:TARGET_WRITE_PC:void:write_pc:CORE_ADDR val, int pid:val, pid::0:0
144 f:1:TARGET_READ_FP:CORE_ADDR:read_fp:void:::0:0
145 f:1:TARGET_WRITE_FP:void:write_fp:CORE_ADDR val:val::0:0
146 f:1:TARGET_READ_SP:CORE_ADDR:read_sp:void:::0:0
147 f:1:TARGET_WRITE_SP:void:write_sp:CORE_ADDR val:val::0:0
149 v:2:NUM_REGS:int:num_regs::::0:-1
150 v:2:SP_REGNUM:int:sp_regnum::::0:-1
151 v:2:FP_REGNUM:int:fp_regnum::::0:-1
152 v:2:PC_REGNUM:int:pc_regnum::::0:-1
153 f:2:REGISTER_NAME:char *:register_name:int regnr:regnr::0:0
154 v:2:REGISTER_SIZE:int:register_size::::0:-1
155 v:2:REGISTER_BYTES:int:register_bytes::::0:-1
156 f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::0:0
157 f:2:REGISTER_RAW_SIZE:int:register_raw_size:int reg_nr:reg_nr::0:0
158 v:2:MAX_REGISTER_RAW_SIZE:int:max_register_raw_size::::0:-1
159 f:2:REGISTER_VIRTUAL_SIZE:int:register_virtual_size:int reg_nr:reg_nr::0:0
160 v:2:MAX_REGISTER_VIRTUAL_SIZE:int:max_register_virtual_size::::0:-1
161 f:2:REGISTER_VIRTUAL_TYPE:struct type *:register_virtual_type:int reg_nr:reg_nr::0:0
163 v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames::::0:-1
164 v:2:CALL_DUMMY_LOCATION:int:call_dummy_location::::0:0
165 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:
166 v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1::0x%08lx
167 v:2:CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset::::0:-1::0x%08lx
168 v:1:CALL_DUMMY_BREAKPOINT_OFFSET_P:int:call_dummy_breakpoint_offset_p::::0:-1
169 v:2:CALL_DUMMY_LENGTH:int:call_dummy_length::::0:-1::::CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END
170 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
171 v:1:CALL_DUMMY_P:int:call_dummy_p::::0:-1
172 v:2:CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:::0x%08lx
173 v:2:SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:::0x%08lx
174 v:1:CALL_DUMMY_STACK_ADJUST_P:int:call_dummy_stack_adjust_p::::0:-1::0x%08lx
175 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
176 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
178 v:2:BELIEVE_PCC_PROMOTION:int:believe_pcc_promotion::::0:::::#
179 v:2:BELIEVE_PCC_PROMOTION_TYPE:int:believe_pcc_promotion_type::::0:::::#
180 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
182 f:1:REGISTER_CONVERTIBLE:int:register_convertible:int nr:nr::0:0
183 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
184 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
186 f:2:EXTRACT_RETURN_VALUE:void:extract_return_value:struct type *type, char *regbuf, char *valbuf:type, regbuf, valbuf::0:0
187 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
188 f:2:PUSH_DUMMY_FRAME:void:push_dummy_frame:void:-::0:0
189 f:1:PUSH_RETURN_ADDRESS:CORE_ADDR:push_return_address:CORE_ADDR pc, CORE_ADDR sp:pc, sp::0:0
190 f:2:POP_FRAME:void:pop_frame:void:-::0:0
192 # I wish that these would just go away....
193 f:2:D10V_MAKE_DADDR:CORE_ADDR:d10v_make_daddr:CORE_ADDR x:x::0:0
194 f:2:D10V_MAKE_IADDR:CORE_ADDR:d10v_make_iaddr:CORE_ADDR x:x::0:0
195 f:2:D10V_DADDR_P:int:d10v_daddr_p:CORE_ADDR x:x::0:0
196 f:2:D10V_IADDR_P:int:d10v_iaddr_p:CORE_ADDR x:x::0:0
197 f:2:D10V_CONVERT_DADDR_TO_RAW:CORE_ADDR:d10v_convert_daddr_to_raw:CORE_ADDR x:x::0:0
198 f:2:D10V_CONVERT_IADDR_TO_RAW:CORE_ADDR:d10v_convert_iaddr_to_raw:CORE_ADDR x:x::0:0
200 f:2:STORE_STRUCT_RETURN:void:store_struct_return:CORE_ADDR addr, CORE_ADDR sp:addr, sp::0:0
201 f:2:STORE_RETURN_VALUE:void:store_return_value:struct type *type, char *valbuf:type, valbuf::0:0
202 f:2:EXTRACT_STRUCT_VALUE_ADDRESS:CORE_ADDR:extract_struct_value_address:char *regbuf:regbuf::0:0
203 f:2:USE_STRUCT_CONVENTION:int:use_struct_convention:int gcc_p, struct type *value_type:gcc_p, value_type::0:0
205 f:2:FRAME_INIT_SAVED_REGS:void:frame_init_saved_regs:struct frame_info *frame:frame::0:0
206 f:2:INIT_EXTRA_FRAME_INFO:void:init_extra_frame_info:int fromleaf, struct frame_info *frame:fromleaf, frame::0:0
208 f:2:SKIP_PROLOGUE:CORE_ADDR:skip_prologue:CORE_ADDR ip:ip::0:0
209 f:2:INNER_THAN:int:inner_than:CORE_ADDR lhs, CORE_ADDR rhs:lhs, rhs::0:0
210 f:2:BREAKPOINT_FROM_PC:unsigned char *:breakpoint_from_pc:CORE_ADDR *pcptr, int *lenptr:pcptr, lenptr::0:0
211 f:2:MEMORY_INSERT_BREAKPOINT:int:memory_insert_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_insert_breakpoint:0
212 f:2:MEMORY_REMOVE_BREAKPOINT:int:memory_remove_breakpoint:CORE_ADDR addr, char *contents_cache:addr, contents_cache::0:default_memory_remove_breakpoint:0
213 v:2:DECR_PC_AFTER_BREAK:CORE_ADDR:decr_pc_after_break::::0:-1
214 v:2:FUNCTION_START_OFFSET:CORE_ADDR:function_start_offset::::0:-1
216 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
218 v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
219 f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi::0:0
220 f:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
221 f:1:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
222 f:2:FRAME_SAVED_PC:CORE_ADDR:frame_saved_pc:struct frame_info *fi:fi::0:0
223 f:2:FRAME_ARGS_ADDRESS:CORE_ADDR:frame_args_address:struct frame_info *fi:fi::0:0
224 f:2:FRAME_LOCALS_ADDRESS:CORE_ADDR:frame_locals_address:struct frame_info *fi:fi::0:0
225 f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:frame::0:0
226 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
237 function_list |
while eval read $read
240 ${class} ${macro}(${actual})
241 ${returntype} ${function} ($formal)${attrib}
249 description=${description}
258 /* Dynamic architecture support for GDB, the GNU debugger.
259 Copyright 1998-1999, Free Software Foundation, Inc.
261 This file is part of GDB.
263 This program is free software; you can redistribute it and/or modify
264 it under the terms of the GNU General Public License as published by
265 the Free Software Foundation; either version 2 of the License, or
266 (at your option) any later version.
268 This program is distributed in the hope that it will be useful,
269 but WITHOUT ANY WARRANTY; without even the implied warranty of
270 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
271 GNU General Public License for more details.
273 You should have received a copy of the GNU General Public License
274 along with this program; if not, write to the Free Software
275 Foundation, Inc., 59 Temple Place - Suite 330,
276 Boston, MA 02111-1307, USA. */
278 /* *INDENT-OFF* */ /* \`\`typedef (f)();'' confuses indent */
280 /* This file was created with the aid of \`\`gdbarch.sh''.
282 The bourn shell script \`\`gdbarch.sh'' creates the files
283 \`\`new-gdbarch.c'' and \`\`new-gdbarch.h and then compares them
284 against the existing \`\`gdbarch.[hc]''. Any differences found
287 If editing this file, please also run gdbarch.sh and merge any
288 changes into that script. Conversely, when makeing sweeping changes
289 to this file, modifying gdbarch.sh and using its output may prove
309 #ifndef GDB_MULTI_ARCH
310 #define GDB_MULTI_ARCH 0
313 extern struct gdbarch *current_gdbarch;
316 /* See gdb/doc/gdbint.texi for a discussion of the GDB_MULTI_ARCH
320 /* If any of the following are defined, the target wasn't correctly
324 #if defined (CALL_DUMMY)
325 #error "CALL_DUMMY: replaced by CALL_DUMMY_WORDS/SIZEOF_CALL_DUMMY_WORDS"
330 #if defined (REGISTER_NAMES)
331 #error "REGISTER_NAMES: replaced by REGISTER_NAME"
336 #if defined (EXTRA_FRAME_INFO)
337 #error "EXTRA_FRAME_INFO: replaced by struct frame_extra_info"
342 #if defined (FRAME_FIND_SAVED_REGS)
343 #error "FRAME_FIND_SAVED_REGS: replaced by FRAME_INIT_SAVED_REGS"
351 echo "/* The following are pre-initialized by GDBARCH. */"
352 function_list |
while eval read $read
357 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
358 echo "/* set_gdbarch_${function}() - not applicable - pre-initialized. */"
359 echo "#if GDB_MULTI_ARCH"
360 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
361 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
371 echo "/* The following are initialized by the target dependant code. */"
372 function_list |
while eval read $read
377 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
378 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, ${returntype} ${function});"
379 echo "#if GDB_MULTI_ARCH"
380 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
381 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
387 echo "typedef ${returntype} (gdbarch_${function}_ftype) (${formal});"
388 if [ "${formal}" = "void" ]
390 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch);"
392 echo "extern ${returntype} gdbarch_${function} (struct gdbarch *gdbarch, ${formal});"
394 echo "extern void set_gdbarch_${function} (struct gdbarch *gdbarch, gdbarch_${function}_ftype *${function});"
395 echo "#if GDB_MULTI_ARCH"
396 echo "#if (GDB_MULTI_ARCH > 1) || !defined (${macro})"
397 if [ "${actual}" = "" ]
399 echo "#define ${macro}() (gdbarch_${function} (current_gdbarch))"
400 elif [ "${actual}" = "-" ]
402 echo "#define ${macro} (gdbarch_${function} (current_gdbarch))"
404 echo "#define ${macro}(${actual}) (gdbarch_${function} (current_gdbarch, ${actual}))"
415 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
418 /* Mechanism for co-ordinating the selection of a specific
421 GDB targets (*-tdep.c) can register an interest in a specific
422 architecture. Other GDB components can register a need to maintain
423 per-architecture data.
425 The mechanisms below ensures that there is only a loose connection
426 between the set-architecture command and the various GDB
427 components. Each component can independantly register their need
428 to maintain architecture specific data with gdbarch.
432 Previously, a single TARGET_ARCHITECTURE_HOOK was provided. It
435 The more traditional mega-struct containing architecture specific
436 data for all the various GDB components was also considered. Since
437 GDB is built from a variable number of (fairly independant)
438 components it was determined that the global aproach was not
442 /* Register a new architectural family with GDB.
444 Register support for the specified ARCHITECTURE with GDB. When
445 gdbarch determines that the specified architecture has been
446 selected, the corresponding INIT function is called.
450 The INIT function takes two parameters: INFO which contains the
451 information available to gdbarch about the (possibly new)
452 architecture; ARCHES which is a list of the previously created
453 \`\`struct gdbarch'' for this architecture.
455 The INIT function parameter INFO shall, as far as possible, be
456 pre-initialized with information obtained from INFO.ABFD or
457 previously selected architecture (if similar). INIT shall ensure
458 that the INFO.BYTE_ORDER is non-zero.
460 The INIT function shall return any of: NULL - indicating that it
461 doesn't reconize the selected architecture; an existing \`\`struct
462 gdbarch'' from the ARCHES list - indicating that the new
463 architecture is just a synonym for an earlier architecture (see
464 gdbarch_list_lookup_by_info()); a newly created \`\`struct gdbarch''
465 - that describes the selected architecture (see
470 struct gdbarch *gdbarch;
471 struct gdbarch_list *next;
476 /* Use default: bfd_arch_unknown (ZERO). */
477 enum bfd_architecture bfd_architecture;
479 /* Use default: NULL (ZERO). */
480 const struct bfd_arch_info *bfd_arch_info;
482 /* Use default: 0 (ZERO). */
485 /* Use default: NULL (ZERO). */
488 /* Use default: NULL (ZERO). */
489 struct gdbarch_tdep_info *tdep_info;
492 typedef struct gdbarch *(gdbarch_init_ftype) (struct gdbarch_info info, struct gdbarch_list *arches);
494 extern void register_gdbarch_init (enum bfd_architecture architecture, gdbarch_init_ftype *);
497 /* Helper function. Search the list of ARCHES for a GDBARCH that
498 matches the information provided by INFO. */
500 extern struct gdbarch_list *gdbarch_list_lookup_by_info (struct gdbarch_list *arches, const struct gdbarch_info *info);
503 /* Helper function. Create a preliminary \`\`struct gdbarch''. Perform
504 basic initialization using values obtained from the INFO andTDEP
505 parameters. set_gdbarch_*() functions are called to complete the
506 initialization of the object. */
508 extern struct gdbarch *gdbarch_alloc (const struct gdbarch_info *info, struct gdbarch_tdep *tdep);
511 /* Helper function. Force an update of the current architecture. Used
512 by legacy targets that have added their own target specific
513 architecture manipulation commands.
515 The INFO parameter shall be fully initialized (\`\`memset (&INFO,
516 sizeof (info), 0)'' set relevant fields) before gdbarch_update() is
517 called. gdbarch_update() shall initialize any \`\`default'' fields
518 using information obtained from the previous architecture or
519 INFO.ABFD (if specified) before calling the corresponding
520 architectures INIT function. */
522 extern int gdbarch_update (struct gdbarch_info info);
526 /* Register per-architecture data-pointer.
528 Reserve space for a per-architecture data-pointer. An identifier
529 for the reserved data-pointer is returned. That identifer should
530 be saved in a local static.
532 When a new architecture is selected, INIT() is called. When a
533 previous architecture is re-selected, the per-architecture
534 data-pointer for that previous architecture is restored (INIT() is
537 INIT() shall return the initial value for the per-architecture
538 data-pointer for the current architecture.
540 Multiple registrarants for any architecture are allowed (and
541 strongly encouraged). */
543 typedef void *(gdbarch_data_ftype) (void);
544 extern struct gdbarch_data *register_gdbarch_data (gdbarch_data_ftype *init);
546 /* Return the value of the per-architecture data-pointer for the
547 current architecture. */
549 extern void *gdbarch_data (struct gdbarch_data*);
553 /* Register per-architecture memory region.
555 Provide a memory-region swap mechanism. Per-architecture memory
556 region are created. These memory regions are swapped whenever the
557 architecture is changed. For a new architecture, the memory region
558 is initialized with zero (0) and the INIT function is called.
560 Memory regions are swapped / initialized in the order that they are
561 registered. NULL DATA and/or INIT values can be specified.
563 New code should use register_gdbarch_data(). */
565 typedef void (gdbarch_swap_ftype) (void);
566 extern void register_gdbarch_swap (void *data, unsigned long size, gdbarch_swap_ftype *init);
567 #define REGISTER_GDBARCH_SWAP(VAR) register_gdbarch_swap (&(VAR), sizeof ((VAR)), NULL)
571 /* The target-system-dependant byte order is dynamic */
573 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
574 is selectable at runtime. The user can use the \`\`set endian''
575 command to change it. TARGET_BYTE_ORDER_AUTO is nonzero when
576 target_byte_order should be auto-detected (from the program image
580 /* Multi-arch GDB is always bi-endian. */
581 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
584 #ifndef TARGET_BYTE_ORDER_SELECTABLE_P
585 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SLECTABLE
586 when they should have defined TARGET_BYTE_ORDER_SELECTABLE_P 1 */
587 #ifdef TARGET_BYTE_ORDER_SELECTABLE
588 #define TARGET_BYTE_ORDER_SELECTABLE_P 1
590 #define TARGET_BYTE_ORDER_SELECTABLE_P 0
594 extern int target_byte_order;
595 #ifdef TARGET_BYTE_ORDER_SELECTABLE
596 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
597 and expect defs.h to re-define TARGET_BYTE_ORDER. */
598 #undef TARGET_BYTE_ORDER
600 #ifndef TARGET_BYTE_ORDER
601 #define TARGET_BYTE_ORDER (target_byte_order + 0)
604 extern int target_byte_order_auto;
605 #ifndef TARGET_BYTE_ORDER_AUTO
606 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
611 /* The target-system-dependant BFD architecture is dynamic */
613 extern int target_architecture_auto;
614 #ifndef TARGET_ARCHITECTURE_AUTO
615 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
618 extern const struct bfd_arch_info *target_architecture;
619 #ifndef TARGET_ARCHITECTURE
620 #define TARGET_ARCHITECTURE (target_architecture + 0)
623 /* Notify the target dependant backend of a change to the selected
624 architecture. A zero return status indicates that the target did
625 not like the change. */
627 extern int (*target_architecture_hook) (const struct bfd_arch_info *);
631 /* The target-system-dependant disassembler is semi-dynamic */
633 #include "dis-asm.h" /* Get defs for disassemble_info */
635 extern int dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr,
636 int len, disassemble_info *info);
638 extern void dis_asm_memory_error (int status, bfd_vma memaddr,
639 disassemble_info *info);
641 extern void dis_asm_print_address (bfd_vma addr,
642 disassemble_info *info);
644 extern int (*tm_print_insn) (bfd_vma, disassemble_info*);
645 extern disassemble_info tm_print_insn_info;
646 #ifndef TARGET_PRINT_INSN
647 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
649 #ifndef TARGET_PRINT_INSN_INFO
650 #define TARGET_PRINT_INSN_INFO (&tm_print_insn_info)
655 /* Explicit test for D10V architecture.
656 USE of these macro's is *STRONGLY* discouraged. */
658 #define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
659 #ifndef D10V_MAKE_DADDR
660 #define D10V_MAKE_DADDR(X) (internal_error ("gdbarch: D10V_MAKE_DADDR"), 0)
662 #ifndef D10V_MAKE_IADDR
663 #define D10V_MAKE_IADDR(X) (internal_error ("gdbarch: D10V_MAKE_IADDR"), 0)
667 /* Fallback definition of FRAMELESS_FUNCTION_INVOCATION */
668 #ifndef FRAMELESS_FUNCTION_INVOCATION
669 #define FRAMELESS_FUNCTION_INVOCATION(FI) (0)
673 /* Fallback definition of REGISTER_CONVERTIBLE etc */
674 extern int generic_register_convertible_not (int reg_nr);
675 #ifndef REGISTER_CONVERTIBLE
676 #define REGISTER_CONVERTIBLE(x) (0)
678 #ifndef REGISTER_CONVERT_TO_VIRTUAL
679 #define REGISTER_CONVERT_TO_VIRTUAL(x, y, z, a)
681 #ifndef REGISTER_CONVERT_TO_RAW
682 #define REGISTER_CONVERT_TO_RAW(x, y, z, a)
686 /* Fallback definition for EXTRACT_STRUCT_VALUE_ADDRESS */
687 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS
688 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (0)
689 #define EXTRACT_STRUCT_VALUE_ADDRESS(X) (internal_error ("gdbarch: EXTRACT_STRUCT_VALUE_ADDRESS"), 0)
691 #ifndef EXTRACT_STRUCT_VALUE_ADDRESS_P
692 #define EXTRACT_STRUCT_VALUE_ADDRESS_P (1)
697 /* Fallback definition for REGISTER_NAME for systems still defining
699 #ifndef REGISTER_NAME
700 extern char *gdb_register_names[];
701 #define REGISTER_NAME(i) gdb_register_names[i]
705 /* Set the dynamic target-system-dependant parameters (architecture,
706 byte-order, ...) using information found in the BFD */
708 extern void set_gdbarch_from_file (bfd *);
711 /* Explicitly set the dynamic target-system-dependant parameters based
712 on bfd_architecture and machine. */
714 extern void set_architecture_from_arch_mach (enum bfd_architecture, unsigned long);
717 /* Initialize the current architecture to the "first" one we find on
720 extern void initialize_current_architecture (void);
722 /* Helper function for targets that don't know how my arguments are
725 extern int frame_num_args_unknown (struct frame_info *fi);
728 /* gdbarch trace variable */
729 extern int gdbarch_debug;
731 extern void gdbarch_dump (void);
736 #../move-if-change new-gdbarch.h gdbarch.h
737 if ! test -r gdbarch.h
739 echo "gdbarch.h missing? cp new-gdbarch.h gdbarch.h" 1>&2
740 elif diff -c gdbarch.h new-gdbarch.h
742 echo "gdbarch.h unchanged" 1>&2
744 echo "gdbarch.h has changed? cp new-gdbarch.h gdbarch.h" 1>&2
760 #include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
762 /* Just include everything in sight so that the every old definition
763 of macro is visible. */
764 #include "gdb_string.h"
768 #include "inferior.h"
769 #include "breakpoint.h"
774 #include "gdbthread.h"
775 #include "annotate.h"
776 #include "symfile.h" /* for overlay functions */
781 /* Static function declarations */
783 static void verify_gdbarch (struct gdbarch *gdbarch);
784 static void init_gdbarch_data (struct gdbarch *);
785 static void init_gdbarch_swap (struct gdbarch *);
786 static void swapout_gdbarch_swap (struct gdbarch *);
787 static void swapin_gdbarch_swap (struct gdbarch *);
789 /* Convenience macro for allocting typesafe memory. */
792 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
796 /* Non-zero if we want to trace architecture code. */
798 #ifndef GDBARCH_DEBUG
799 #define GDBARCH_DEBUG 0
801 int gdbarch_debug = GDBARCH_DEBUG;
805 # gdbarch open the gdbarch object
807 echo "/* Maintain the struct gdbarch object */"
809 echo "struct gdbarch"
811 echo " /* basic architectural information */"
812 function_list |
while eval read $read
815 "i" ) echo " ${returntype} ${function};" ;;
819 echo " /* target specific vector. */"
820 echo " struct gdbarch_tdep *tdep;"
822 echo " /* per-architecture data-pointers */"
826 echo " /* per-architecture swap-regions */"
827 echo " struct gdbarch_swap *swap;"
830 /* Multi-arch values.
832 When extending this structure you must:
836 Declare set/get functions and define the corresponding
839 gdbarch_alloc(): If zero/NULL is not a suitable default,
840 initialize the new field.
842 verify_gdbarch(): Confirm that the target updated the field
845 gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
848 \`\`default_gdbarch()'': Append an initial value to the static
849 variable (base values on the host's c-type system).
851 get_gdbarch(): Implement the set/get functions (probably using
852 the macro's as shortcuts).
857 function_list |
while eval read $read
860 "v" ) echo " ${returntype} ${function};" ;;
861 "f" ) echo " gdbarch_${function}_ftype *${function}${attrib};" ;;
866 # A pre-initialized vector
870 /* The default architecture uses host values (for want of a better
874 echo "extern const struct bfd_arch_info bfd_default_arch_struct;"
876 echo "struct gdbarch default_gdbarch = {"
877 echo " /* basic architecture information */"
878 function_list |
while eval read $read
881 "i" ) echo " ${default}," ;;
885 /* target specific vector */
887 /*per-architecture data-pointers and swap regions */
889 /* Multi-arch values */
891 function_list |
while eval read $read
894 "f" |
"v" ) echo " ${default}," ;;
898 /* default_gdbarch() */
900 struct gdbarch *current_gdbarch = &default_gdbarch;
903 # Create a new gdbarch struct
907 /* Create a new \`\`struct gdbarch'' based in information provided by
908 \`\`struct gdbarch_info''. */
913 gdbarch_alloc (const struct gdbarch_info *info,
914 struct gdbarch_tdep *tdep)
916 struct gdbarch *gdbarch = XMALLOC (struct gdbarch);
917 memset (gdbarch, 0, sizeof (*gdbarch));
919 gdbarch->tdep = tdep;
922 function_list |
while eval read $read
925 "i" ) echo " gdbarch->${function} = info->${function};"
929 echo " /* Force the explicit initialization of these. */"
930 function_list |
while eval read $read
934 if [ "${init}" != "" -a "${init}" != "0" ]
936 echo " gdbarch->${function} = ${init};"
942 /* gdbarch_alloc() */
948 # verify a new architecture
951 echo "/* Ensure that all values in a GDBARCH are reasonable. */"
955 verify_gdbarch (struct gdbarch *gdbarch)
957 /* Only perform sanity checks on a multi-arch target. */
958 if (GDB_MULTI_ARCH <= 0)
961 if (gdbarch->byte_order == 0)
962 internal_error ("verify_gdbarch: byte-order unset");
963 if (gdbarch->bfd_arch_info == NULL)
964 internal_error ("verify_gdbarch: bfd_arch_info unset");
965 /* Check those that need to be defined for the given multi-arch level. */
967 function_list |
while eval read $read
973 echo " if ((GDB_MULTI_ARCH >= ${level})"
974 echo " && (${init_p}))"
975 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
978 echo " if ((GDB_MULTI_ARCH >= ${level})"
979 echo " && (gdbarch->${function} == ${init}))"
980 echo " internal_error (\"gdbarch: verify_gdbarch: ${function} invalid\");"
992 echo "/* Print out the details of the current architecture. */"
999 function_list |
while eval read $read
1003 echo " fprintf_unfiltered (gdb_stdlog,"
1004 echo " \"gdbarch_update: ${macro} = 0x%08lx\\n\","
1005 echo " (long) current_gdbarch->${function}"
1006 echo " /*${macro} ()*/);"
1009 test "${fmt}" ||
fmt="%ld"
1010 test "${print}" || print
="(long) ${macro}"
1011 if [ "${print_p}" = "#" ]
1013 echo "#ifdef ${macro}"
1014 echo " fprintf_unfiltered (gdb_stdlog,"
1015 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1018 elif [ "${print_p}" ]
1020 echo " if (${print_p})"
1021 echo " fprintf_unfiltered (gdb_stdlog,"
1022 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1025 echo " fprintf_unfiltered (gdb_stdlog,"
1026 echo " \"gdbarch_update: ${macro} = ${fmt}\\n\","
1038 struct gdbarch_tdep *
1039 gdbarch_tdep (struct gdbarch *gdbarch)
1041 if (gdbarch_debug >= 2)
1042 /* FIXME: gdb_std??? */
1043 fprintf_unfiltered (gdb_stdlog, "gdbarch_tdep called\n");
1044 return gdbarch->tdep;
1048 function_list |
while eval read $read
1053 echo "${returntype}"
1054 if [ "${formal}" = "void" ]
1056 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1058 echo "gdbarch_${function} (struct gdbarch *gdbarch, ${formal})"
1061 echo " if (gdbarch->${function} == 0)"
1062 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1063 echo " if (gdbarch_debug >= 2)"
1064 echo " /* FIXME: gdb_std??? */"
1065 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1066 test "${actual}" = "-" && actual
=""
1067 if [ "${returntype}" = "void" ]
1069 echo " gdbarch->${function} (${actual});"
1071 echo " return gdbarch->${function} (${actual});"
1076 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1077 echo " `echo ${function} | sed -e 's/./ /g'` gdbarch_${function}_ftype ${function})"
1079 echo " gdbarch->${function} = ${function};"
1084 echo "${returntype}"
1085 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1089 echo " if (${init_p})"
1090 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1093 echo " if (gdbarch->${function} == ${init})"
1094 echo " internal_error (\"gdbarch: gdbarch_${function} invalid\");"
1096 echo " if (gdbarch_debug >= 2)"
1097 echo " /* FIXME: gdb_std??? */"
1098 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1099 echo " return gdbarch->${function};"
1103 echo "set_gdbarch_${function} (struct gdbarch *gdbarch,"
1104 echo " `echo ${function} | sed -e 's/./ /g'` ${returntype} ${function})"
1106 echo " gdbarch->${function} = ${function};"
1111 echo "${returntype}"
1112 echo "gdbarch_${function} (struct gdbarch *gdbarch)"
1114 echo " if (gdbarch_debug >= 2)"
1115 echo " /* FIXME: gdb_std??? */"
1116 echo " fprintf_unfiltered (gdb_stdlog, \"gdbarch_${function} called\n\");"
1117 echo " return gdbarch->${function};"
1123 # All the trailing guff
1127 /* Keep a registrary of per-architecture data-pointers required by GDB
1135 struct gdbarch_data_registration
1137 gdbarch_data_ftype *init;
1138 struct gdbarch_data *data;
1139 struct gdbarch_data_registration *next;
1142 struct gdbarch_data_registrary
1145 struct gdbarch_data_registration *registrations;
1148 struct gdbarch_data_registrary gdbarch_data_registrary =
1153 struct gdbarch_data *
1154 register_gdbarch_data (gdbarch_data_ftype *init)
1156 struct gdbarch_data_registration **curr;
1157 for (curr = &gdbarch_data_registrary.registrations;
1159 curr = &(*curr)->next);
1160 (*curr) = XMALLOC (struct gdbarch_data_registration);
1161 (*curr)->next = NULL;
1162 (*curr)->init = init;
1163 (*curr)->data = XMALLOC (struct gdbarch_data);
1164 (*curr)->data->index = gdbarch_data_registrary.nr++;
1165 return (*curr)->data;
1169 /* Walk through all the registered users initializing each in turn. */
1172 init_gdbarch_data (struct gdbarch *gdbarch)
1174 struct gdbarch_data_registration *rego;
1175 gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
1176 gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
1177 for (rego = gdbarch_data_registrary.registrations;
1181 if (rego->data->index < gdbarch->nr_data)
1182 gdbarch->data[rego->data->index] = rego->init ();
1187 /* Return the current value of the specified per-architecture
1192 struct gdbarch_data *data;
1194 if (data->index >= current_gdbarch->nr_data)
1195 internal_error ("gdbarch_data: request for non-existant data.");
1196 return current_gdbarch->data[data->index];
1201 /* Keep a registrary of swaped data required by GDB modules. */
1206 struct gdbarch_swap_registration *source;
1207 struct gdbarch_swap *next;
1210 struct gdbarch_swap_registration
1213 unsigned long sizeof_data;
1214 gdbarch_swap_ftype *init;
1215 struct gdbarch_swap_registration *next;
1218 struct gdbarch_swap_registrary
1221 struct gdbarch_swap_registration *registrations;
1224 struct gdbarch_swap_registrary gdbarch_swap_registrary =
1230 register_gdbarch_swap (void *data,
1231 unsigned long sizeof_data,
1232 gdbarch_swap_ftype *init)
1234 struct gdbarch_swap_registration **rego;
1235 for (rego = &gdbarch_swap_registrary.registrations;
1237 rego = &(*rego)->next);
1238 (*rego) = XMALLOC (struct gdbarch_swap_registration);
1239 (*rego)->next = NULL;
1240 (*rego)->init = init;
1241 (*rego)->data = data;
1242 (*rego)->sizeof_data = sizeof_data;
1247 init_gdbarch_swap (struct gdbarch *gdbarch)
1249 struct gdbarch_swap_registration *rego;
1250 struct gdbarch_swap **curr = &gdbarch->swap;
1251 for (rego = gdbarch_swap_registrary.registrations;
1255 if (rego->data != NULL)
1257 (*curr) = XMALLOC (struct gdbarch_swap);
1258 (*curr)->source = rego;
1259 (*curr)->swap = xmalloc (rego->sizeof_data);
1260 (*curr)->next = NULL;
1261 memset (rego->data, 0, rego->sizeof_data);
1262 curr = &(*curr)->next;
1264 if (rego->init != NULL)
1270 swapout_gdbarch_swap (struct gdbarch *gdbarch)
1272 struct gdbarch_swap *curr;
1273 for (curr = gdbarch->swap;
1276 memcpy (curr->swap, curr->source->data, curr->source->sizeof_data);
1280 swapin_gdbarch_swap (struct gdbarch *gdbarch)
1282 struct gdbarch_swap *curr;
1283 for (curr = gdbarch->swap;
1286 memcpy (curr->source->data, curr->swap, curr->source->sizeof_data);
1290 /* Keep a registrary of the architectures known by GDB. */
1292 struct gdbarch_init_registration
1294 enum bfd_architecture bfd_architecture;
1295 gdbarch_init_ftype *init;
1296 struct gdbarch_list *arches;
1297 struct gdbarch_init_registration *next;
1300 static struct gdbarch_init_registration *gdbarch_init_registrary = NULL;
1303 register_gdbarch_init (enum bfd_architecture bfd_architecture,
1304 gdbarch_init_ftype *init)
1306 struct gdbarch_init_registration **curr;
1307 const struct bfd_arch_info *bfd_arch_info;
1308 /* Check that BFD reconizes this architecture */
1309 bfd_arch_info = bfd_lookup_arch (bfd_architecture, 0);
1310 if (bfd_arch_info == NULL)
1312 internal_error ("gdbarch: Attempt to register unknown architecture (%d)", bfd_architecture);
1314 /* Check that we haven't seen this architecture before */
1315 for (curr = &gdbarch_init_registrary;
1317 curr = &(*curr)->next)
1319 if (bfd_architecture == (*curr)->bfd_architecture)
1320 internal_error ("gdbarch: Duplicate registraration of architecture (%s)",
1321 bfd_arch_info->printable_name);
1325 fprintf_unfiltered (gdb_stdlog, "register_gdbarch_init (%s, 0x%08lx)\n",
1326 bfd_arch_info->printable_name,
1329 (*curr) = XMALLOC (struct gdbarch_init_registration);
1330 (*curr)->bfd_architecture = bfd_architecture;
1331 (*curr)->init = init;
1332 (*curr)->arches = NULL;
1333 (*curr)->next = NULL;
1338 /* Look for an architecture using gdbarch_info. Base search on only
1339 BFD_ARCH_INFO and BYTE_ORDER. */
1341 struct gdbarch_list *
1342 gdbarch_list_lookup_by_info (struct gdbarch_list *arches,
1343 const struct gdbarch_info *info)
1345 for (; arches != NULL; arches = arches->next)
1347 if (info->bfd_arch_info != arches->gdbarch->bfd_arch_info)
1349 if (info->byte_order != arches->gdbarch->byte_order)
1357 /* Update the current architecture. Return ZERO if the update request
1361 gdbarch_update (struct gdbarch_info info)
1363 struct gdbarch *new_gdbarch;
1364 struct gdbarch_list **list;
1365 struct gdbarch_init_registration *rego;
1367 /* Fill in any missing bits. Most important is the bfd_architecture
1368 which is used to select the target architecture. */
1369 if (info.bfd_architecture == bfd_arch_unknown)
1371 if (info.bfd_arch_info != NULL)
1372 info.bfd_architecture = info.bfd_arch_info->arch;
1373 else if (info.abfd != NULL)
1374 info.bfd_architecture = bfd_get_arch (info.abfd);
1375 /* FIXME - should query BFD for its default architecture. */
1377 info.bfd_architecture = current_gdbarch->bfd_arch_info->arch;
1379 if (info.bfd_arch_info == NULL)
1381 if (target_architecture_auto && info.abfd != NULL)
1382 info.bfd_arch_info = bfd_get_arch_info (info.abfd);
1384 info.bfd_arch_info = current_gdbarch->bfd_arch_info;
1386 if (info.byte_order == 0)
1388 if (target_byte_order_auto && info.abfd != NULL)
1389 info.byte_order = (bfd_big_endian (info.abfd) ? BIG_ENDIAN
1390 : bfd_little_endian (info.abfd) ? LITTLE_ENDIAN
1393 info.byte_order = current_gdbarch->byte_order;
1394 /* FIXME - should query BFD for its default byte-order. */
1396 /* A default for abfd? */
1398 /* Find the target that knows about this architecture. */
1399 for (rego = gdbarch_init_registrary;
1400 rego != NULL && rego->bfd_architecture != info.bfd_architecture;
1405 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: No matching architecture\n");
1411 fprintf_unfiltered (gdb_stdlog,
1412 "gdbarch_update: info.bfd_architecture %d (%s)\n",
1413 info.bfd_architecture,
1414 bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
1415 fprintf_unfiltered (gdb_stdlog,
1416 "gdbarch_update: info.bfd_arch_info %s\n",
1417 (info.bfd_arch_info != NULL
1418 ? info.bfd_arch_info->printable_name
1420 fprintf_unfiltered (gdb_stdlog,
1421 "gdbarch_update: info.byte_order %d (%s)\n",
1423 (info.byte_order == BIG_ENDIAN ? "big"
1424 : info.byte_order == LITTLE_ENDIAN ? "little"
1426 fprintf_unfiltered (gdb_stdlog,
1427 "gdbarch_update: info.abfd 0x%lx\n",
1429 fprintf_unfiltered (gdb_stdlog,
1430 "gdbarch_update: info.tdep_info 0x%lx\n",
1431 (long) info.tdep_info);
1434 /* Ask the target for a replacement architecture. */
1435 new_gdbarch = rego->init (info, rego->arches);
1437 /* Did the target like it? No. Reject the change. */
1438 if (new_gdbarch == NULL)
1441 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Target rejected architecture\n");
1445 /* Did the architecture change? No. Do nothing. */
1446 if (current_gdbarch == new_gdbarch)
1449 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Architecture 0x%08lx (%s) unchanged\n",
1451 new_gdbarch->bfd_arch_info->printable_name);
1455 /* Swap all data belonging to the old target out */
1456 swapout_gdbarch_swap (current_gdbarch);
1458 /* Is this a pre-existing architecture? Yes. Swap it in. */
1459 for (list = ®o->arches;
1461 list = &(*list)->next)
1463 if ((*list)->gdbarch == new_gdbarch)
1466 fprintf_unfiltered (gdb_stdlog, "gdbarch_update: Previous architecture 0x%08lx (%s) selected\n",
1468 new_gdbarch->bfd_arch_info->printable_name);
1469 current_gdbarch = new_gdbarch;
1470 swapin_gdbarch_swap (new_gdbarch);
1475 /* Append this new architecture to this targets list. */
1476 (*list) = XMALLOC (struct gdbarch_list);
1477 (*list)->next = NULL;
1478 (*list)->gdbarch = new_gdbarch;
1480 /* Switch to this new architecture. Dump it out. */
1481 current_gdbarch = new_gdbarch;
1484 fprintf_unfiltered (gdb_stdlog,
1485 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
1487 new_gdbarch->bfd_arch_info->printable_name);
1491 /* Check that the newly installed architecture is valid. */
1492 verify_gdbarch (new_gdbarch);
1494 /* Initialize the per-architecture memory (swap) areas.
1495 CURRENT_GDBARCH must be update before these modules are
1497 init_gdbarch_swap (new_gdbarch);
1499 /* Initialize the per-architecture data-pointer of all parties that
1500 registered an interest in this architecture. CURRENT_GDBARCH
1501 must be updated before these modules are called. */
1502 init_gdbarch_data (new_gdbarch);
1509 /* Functions to manipulate the endianness of the target. */
1511 #ifdef TARGET_BYTE_ORDER_SELECTABLE
1512 /* compat - Catch old targets that expect a selectable byte-order to
1513 default to BIG_ENDIAN */
1514 #ifndef TARGET_BYTE_ORDER_DEFAULT
1515 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
1518 #if !TARGET_BYTE_ORDER_SELECTABLE_P
1519 #ifndef TARGET_BYTE_ORDER_DEFAULT
1520 /* compat - Catch old non byte-order selectable targets that do not
1521 define TARGET_BYTE_ORDER_DEFAULT and instead expect
1522 TARGET_BYTE_ORDER to be used as the default. For targets that
1523 defined neither TARGET_BYTE_ORDER nor TARGET_BYTE_ORDER_DEFAULT the
1524 below will get a strange compiler warning. */
1525 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
1528 #ifndef TARGET_BYTE_ORDER_DEFAULT
1529 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
1531 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
1532 int target_byte_order_auto = 1;
1534 /* Chain containing the \"set endian\" commands. */
1535 static struct cmd_list_element *endianlist = NULL;
1537 /* Called by \`\`show endian''. */
1539 show_endian (char *args, int from_tty)
1542 (TARGET_BYTE_ORDER_AUTO
1543 ? "The target endianness is set automatically (currently %s endian)\n"
1544 : "The target is assumed to be %s endian\n");
1545 printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
1548 /* Called if the user enters \`\`set endian'' without an argument. */
1550 set_endian (char *args, int from_tty)
1552 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
1553 show_endian (args, from_tty);
1556 /* Called by \`\`set endian big''. */
1558 set_endian_big (char *args, int from_tty)
1560 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1562 target_byte_order = BIG_ENDIAN;
1563 target_byte_order_auto = 0;
1566 struct gdbarch_info info;
1567 memset (&info, 0, sizeof info);
1568 info.byte_order = BIG_ENDIAN;
1569 gdbarch_update (info);
1574 printf_unfiltered ("Byte order is not selectable.");
1575 show_endian (args, from_tty);
1579 /* Called by \`\`set endian little''. */
1581 set_endian_little (char *args, int from_tty)
1583 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1585 target_byte_order = LITTLE_ENDIAN;
1586 target_byte_order_auto = 0;
1589 struct gdbarch_info info;
1590 memset (&info, 0, sizeof info);
1591 info.byte_order = LITTLE_ENDIAN;
1592 gdbarch_update (info);
1597 printf_unfiltered ("Byte order is not selectable.");
1598 show_endian (args, from_tty);
1602 /* Called by \`\`set endian auto''. */
1604 set_endian_auto (char *args, int from_tty)
1606 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1608 target_byte_order_auto = 1;
1612 printf_unfiltered ("Byte order is not selectable.");
1613 show_endian (args, from_tty);
1617 /* Set the endianness from a BFD. */
1619 set_endian_from_file (bfd *abfd)
1621 if (TARGET_BYTE_ORDER_SELECTABLE_P)
1625 if (bfd_big_endian (abfd))
1628 want = LITTLE_ENDIAN;
1629 if (TARGET_BYTE_ORDER_AUTO)
1630 target_byte_order = want;
1631 else if (TARGET_BYTE_ORDER != want)
1632 warning ("%s endian file does not match %s endian target.",
1633 want == BIG_ENDIAN ? "big" : "little",
1634 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1638 if (bfd_big_endian (abfd)
1639 ? TARGET_BYTE_ORDER != BIG_ENDIAN
1640 : TARGET_BYTE_ORDER == BIG_ENDIAN)
1641 warning ("%s endian file does not match %s endian target.",
1642 bfd_big_endian (abfd) ? "big" : "little",
1643 TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little");
1649 /* Functions to manipulate the architecture of the target */
1651 enum set_arch { set_arch_auto, set_arch_manual };
1653 int target_architecture_auto = 1;
1654 extern const struct bfd_arch_info bfd_default_arch_struct;
1655 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
1656 int (*target_architecture_hook) (const struct bfd_arch_info *ap);
1658 static void show_endian (char *, int);
1659 static void set_endian (char *, int);
1660 static void set_endian_big (char *, int);
1661 static void set_endian_little (char *, int);
1662 static void set_endian_auto (char *, int);
1663 static void set_endian_from_file (bfd *);
1664 static int arch_ok (const struct bfd_arch_info *arch);
1665 static void set_arch (const struct bfd_arch_info *arch, enum set_arch type);
1666 static void show_architecture (char *, int);
1667 static void set_architecture (char *, int);
1668 static void info_architecture (char *, int);
1669 static void set_architecture_from_file (bfd *);
1671 /* Do the real work of changing the current architecture */
1674 arch_ok (const struct bfd_arch_info *arch)
1676 /* Should be performing the more basic check that the binary is
1677 compatible with GDB. */
1678 /* Check with the target that the architecture is valid. */
1679 return (target_architecture_hook == NULL
1680 || target_architecture_hook (arch));
1684 set_arch (const struct bfd_arch_info *arch,
1690 if (!arch_ok (arch))
1691 warning ("Target may not support %s architecture",
1692 arch->printable_name);
1693 target_architecture = arch;
1695 case set_arch_manual:
1696 if (!arch_ok (arch))
1698 printf_unfiltered ("Target does not support \`%s' architecture.\n",
1699 arch->printable_name);
1703 target_architecture_auto = 0;
1704 target_architecture = arch;
1712 /* Called if the user enters \`\`show architecture'' without an argument. */
1714 show_architecture (char *args, int from_tty)
1717 arch = TARGET_ARCHITECTURE->printable_name;
1718 if (target_architecture_auto)
1719 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch);
1721 printf_filtered ("The target architecture is assumed to be %s\n", arch);
1724 /* Called if the user enters \`\`set architecture'' with or without an
1727 set_architecture (char *args, int from_tty)
1731 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
1733 else if (strcmp (args, "auto") == 0)
1735 target_architecture_auto = 1;
1737 else if (GDB_MULTI_ARCH)
1739 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1741 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1744 struct gdbarch_info info;
1745 memset (&info, 0, sizeof info);
1746 info.bfd_arch_info = arch;
1747 if (gdbarch_update (info))
1748 target_architecture_auto = 0;
1750 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1755 const struct bfd_arch_info *arch = bfd_scan_arch (args);
1757 set_arch (arch, set_arch_manual);
1759 printf_unfiltered ("Architecture \`%s' not reconized.\n", args);
1763 /* Called if the user enters \`\`info architecture'' without an argument. */
1765 info_architecture (char *args, int from_tty)
1767 enum bfd_architecture a;
1770 if (gdbarch_init_registrary != NULL)
1772 struct gdbarch_init_registration *rego;
1773 printf_filtered ("Available architectures are:\n");
1774 for (rego = gdbarch_init_registrary;
1778 const struct bfd_arch_info *ap;
1779 ap = bfd_lookup_arch (rego->bfd_architecture, 0);
1784 printf_filtered (" %s", ap->printable_name);
1788 printf_filtered ("\n");
1794 printf_filtered ("There are no available architectures.\n");
1798 printf_filtered ("Available architectures are:\n");
1799 for (a = bfd_arch_obscure + 1; a < bfd_arch_last; a++)
1801 const struct bfd_arch_info *ap = bfd_lookup_arch (a, 0);
1806 printf_filtered (" %s", ap->printable_name);
1810 printf_filtered ("\n");
1815 /* Set the architecture from arch/machine */
1817 set_architecture_from_arch_mach (arch, mach)
1818 enum bfd_architecture arch;
1821 const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
1823 set_arch (wanted, set_arch_manual);
1825 internal_error ("gdbarch: hardwired architecture/machine not reconized");
1828 /* Set the architecture from a BFD */
1830 set_architecture_from_file (bfd *abfd)
1832 const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
1833 if (target_architecture_auto)
1835 set_arch (wanted, set_arch_auto);
1837 else if (wanted != target_architecture)
1839 warning ("%s architecture file may be incompatible with %s target.",
1840 wanted->printable_name,
1841 target_architecture->printable_name);
1846 /* Misc helper functions for targets. */
1849 frame_num_args_unknown (fi)
1850 struct frame_info *fi;
1857 generic_register_convertible_not (num)
1865 /* Pointer to the target-dependent disassembly function. */
1866 int (*tm_print_insn) (bfd_vma, disassemble_info *);
1867 disassemble_info tm_print_insn_info;
1871 /* Set the dynamic target-system-dependant parameters (architecture,
1872 byte-order) using information found in the BFD */
1875 set_gdbarch_from_file (abfd)
1880 struct gdbarch_info info;
1881 memset (&info, 0, sizeof info);
1883 gdbarch_update (info);
1886 set_architecture_from_file (abfd);
1887 set_endian_from_file (abfd);
1891 #if defined (CALL_DUMMY)
1892 /* FIXME - this should go away */
1893 LONGEST call_dummy_words[] = CALL_DUMMY;
1894 int sizeof_call_dummy_words = sizeof (call_dummy_words);
1898 /* Initialize the current architecture. */
1900 initialize_current_architecture ()
1904 struct gdbarch_init_registration *rego;
1905 const struct bfd_arch_info *chosen = NULL;
1906 for (rego = gdbarch_init_registrary; rego != NULL; rego = rego->next)
1908 const struct bfd_arch_info *ap
1909 = bfd_lookup_arch (rego->bfd_architecture, 0);
1911 /* Choose the first architecture alphabetically. */
1913 || strcmp (ap->printable_name, chosen->printable_name) < 0)
1919 struct gdbarch_info info;
1920 memset (&info, 0, sizeof info);
1921 info.bfd_arch_info = chosen;
1922 gdbarch_update (info);
1927 extern void _initialize_gdbarch (void);
1929 _initialize_gdbarch ()
1931 add_prefix_cmd ("endian", class_support, set_endian,
1932 "Set endianness of target.",
1933 &endianlist, "set endian ", 0, &setlist);
1934 add_cmd ("big", class_support, set_endian_big,
1935 "Set target as being big endian.", &endianlist);
1936 add_cmd ("little", class_support, set_endian_little,
1937 "Set target as being little endian.", &endianlist);
1938 add_cmd ("auto", class_support, set_endian_auto,
1939 "Select target endianness automatically.", &endianlist);
1940 add_cmd ("endian", class_support, show_endian,
1941 "Show endianness of target.", &showlist);
1943 add_cmd ("architecture", class_support, set_architecture,
1944 "Set architecture of target.", &setlist);
1945 add_alias_cmd ("processor", "architecture", class_support, 1, &setlist);
1946 add_cmd ("architecture", class_support, show_architecture,
1947 "Show architecture of target.", &showlist);
1948 add_cmd ("architecture", class_support, info_architecture,
1949 "List supported target architectures", &infolist);
1951 INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
1952 tm_print_insn_info.flavour = bfd_target_unknown_flavour;
1953 tm_print_insn_info.read_memory_func = dis_asm_read_memory;
1954 tm_print_insn_info.memory_error_func = dis_asm_memory_error;
1955 tm_print_insn_info.print_address_func = dis_asm_print_address;
1957 add_show_from_set (add_set_cmd ("archdebug",
1960 (char *)&gdbarch_debug,
1961 "Set architecture debugging.\n\\
1962 When non-zero, architecture debugging is enabled.", &setlist),
1969 #../move-if-change new-gdbarch.c gdbarch.c
1970 if ! test -r gdbarch.c
1972 echo "gdbarch.c missing? cp new-gdbarch.c gdbarch.c" 1>&2
1973 elif diff -c gdbarch.c new-gdbarch.c
1975 echo "gdbarch.c unchanged" 1>&2
1977 echo "gdbarch.c has changed? cp new-gdbarch.c gdbarch.c" 1>&2
This page took 0.075583 seconds and 4 git commands to generate.